{"authors":[],"description":"杰哥的{教学，运维，编程，调板子}小笔记","feed_url":"https://jia.je/feed_json_created.json","home_page_url":"https://jia.je/","icon":null,"items":[{"authors":[],"content_html":"<h1 id=\"修复绿联-ug307-95348-hdmi-采集卡颜色问题二\">修复绿联 UG307-95348 HDMI 采集卡颜色问题（二）</h1>\n<h2 id=\"背景\">背景</h2>\n<p>经过 <a href=\"../../../09/12/fix-ugreen-95348/\">上文</a> 的一系列修复，绿联 95348 终于是可以正确地还原 MateBook Pro 输出的 RGB 色彩了。但是，换到另一台运行 Windows 的笔记本上时，又出现了新的颜色问题，这篇博客就来探讨一下怎么解决新的问题。</p>\n<!-- more -->\n\n<h2 id=\"颜色问题\">颜色问题</h2>\n<h3 id=\"现象\">现象</h3>\n<p>用着之前打过 patch、关闭 luma processing 和 chroma processing 的固件，给一台 Windows 机器采集的时候，出现了新的问题，颜色出现了新的偏差：</p>\n<ul>\n<li>0,0,0 -&gt; 16,16,16</li>\n<li>255,0,0 -&gt; 237,14,15</li>\n<li>0,255,0 -&gt; 13,236,12</li>\n<li>0,0,255 -&gt; 15,15,238</li>\n<li>255,255,255 -&gt; 234,234,234</li>\n</ul>\n<p>在显卡软件里，可以看到这组偏差对应的是 YCbCr，用的是 Limited range。经过验算，这就是把 Limited range 的 YCbCr 当 Full range 来解析，导致的问题。</p>\n<details class=\"note\">\n<summary>验算过程</summary>\n<p>这五个颜色对应的 YCbCr（BT.709 limited）和按 full range 解码的结果是：</p>\n<table>\n<thead>\n<tr>\n<th>输入 RGB</th>\n<th>YCbCr（limited）</th>\n<th>按 full 解码</th>\n<th>实测</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0,0,0</td>\n<td>16,128,128</td>\n<td>16,16,16</td>\n<td>16,16,16</td>\n</tr>\n<tr>\n<td>255,0,0</td>\n<td>63,102,240</td>\n<td>239,15,15</td>\n<td>237,14,15</td>\n</tr>\n<tr>\n<td>0,255,0</td>\n<td>173,42,26</td>\n<td>12,237,13</td>\n<td>13,236,12</td>\n</tr>\n<tr>\n<td>0,0,255</td>\n<td>32,240,118</td>\n<td>16,16,240</td>\n<td>15,15,238</td>\n</tr>\n<tr>\n<td>255,255,255</td>\n<td>235,128,128</td>\n<td>235,235,235</td>\n<td>234,234,234</td>\n</tr>\n</tbody>\n</table>\n<p>按 full range 解码的公式是：</p>\n<ul>\n<li><code>R = Y + 1.5748 (Cr - 128)</code></li>\n<li><code>G = Y - 0.1873 (Cb - 128) - 0.4681 (Cr - 128)</code></li>\n<li><code>B = Y + 1.8556 (Cb - 128)</code></li>\n</ul>\n<p>以红色 255,0,0 为例，对应的 YCbCr 是 (63,102,240)，代入：</p>\n<ul>\n<li><code>R = 63 + 1.5748 × (240 - 128) = 239.4 → 239</code></li>\n<li><code>G = 63 - 0.1873 × (102 - 128) - 0.4681 × (240 - 128) = 15.44 → 15</code></li>\n<li><code>B = 63 + 1.8556 × (102 - 128) = 14.75 → 15</code></li>\n</ul>\n<p>得到 239,15,15，实测是 237,14,15，只差 1~2 个 LSB。</p>\n<p>如果按 limited range 解码，公式则是：</p>\n<ul>\n<li><code>R = 1.164 (Y - 16) + 1.793 (Cr - 128)</code></li>\n<li><code>G = 1.164 (Y - 16) - 0.213 (Cb - 128) - 0.533 (Cr - 128)</code></li>\n<li><code>B = 1.164 (Y - 16) + 2.112 (Cb - 128)</code></li>\n</ul>\n<p>代入红色：</p>\n<ul>\n<li><code>R = 1.164 × (63 - 16) + 1.793 × (240 - 128) = 255.5 → 255</code></li>\n<li><code>G = 1.164 × (63 - 16) - 0.213 × (102 - 128) - 0.533 × (240 - 128) = 0.6 → 1</code></li>\n<li><code>B = 1.164 × (63 - 16) + 2.112 × (102 - 128) = -0.2 → 0</code></li>\n</ul>\n<p>得到 255,1,0，基本就是正确的 255,0,0（1 个 LSB 的差来自 YCbCr 量化）。所以采集卡确实把 limited 的 YCbCr 当 full 来解了。</p>\n</details>\n<p>如果用显卡软件切换到 RGB 4:4:4 Limited range：</p>\n<ul>\n<li>0,0,0 -&gt; 16,16,16</li>\n<li>255,0,0 -&gt; 232,16,16</li>\n<li>0,255,0 -&gt; 15,234,13</li>\n<li>0,0,255 -&gt; 15,16,234</li>\n<li>255,255,255 -&gt; 233,233,233</li>\n</ul>\n<p>RGB 的 limited range 则是把 0~255 线性压到 16~235：</p>\n<p><code>v_lim = 16 + 219 * v / 255</code></p>\n<p>比如 255 会变成 <code>16 + 219 × 255 / 255 = 235</code>，0 会变成 16。要还原回 full，需要 <code>v = (v_lim - 16) * 255 / 219</code>；采集卡没有做这一步，而是直接把 16~235 当成 0~255 用，所以纯色分量停在 232~234（理论值 235，差值来自采集卡内部的转换和舍入），另外两个分量是 16。</p>\n<p>这也是类似的问题，只有把颜色切换到 RGB 4:4:4 Full range 才可以正确采集。</p>\n<p>虽然可以通过手动指定 RGB 4:4:4 Full range 模式来解决颜色问题，但如果没有装对应的软件呢？又或者像鸿蒙和 macOS（macOS 其实有<a href=\"http://github.com/jiegec/mac-displayctl\">私有 API 可以用</a>）那样没有类似的设置入口呢？</p>\n<p>于是就要看，显卡驱动都是怎么判断要选择什么模式的。</p>\n<h3 id=\"edid\">EDID</h3>\n<p>答案就在 EDID 里面。按照 CEA-861 标准，显示器通过 EDID 告诉显卡，它支持哪些颜色模式，比如是否支持 YCbCr 4:4:4 等等，又具体支持哪些分辨率，哪些时序。</p>\n<p>然后显卡驱动挑选一个时序，让显卡按照一定的波形来把显示输出通过 HDMI 发送给显示器。此时发送的内容，就有颜色（RGB/YCbCr）以及范围（Full/Limited）之分。那这是怎么决定的呢？</p>\n<p>首先，CEA-861 标准规定了一个默认值：对于 CE Timing，默认是 Limited；对于 IT Timing，默认是 Full。什么是 CE Timing 呢？CEA-861 的定义是，出现在标准的 Table 1 表格里，且 VIC 大于 1 的时序，都是 CE Timing。这些 VIC 可以在 <a href=\"https://jia.je/kb/hardware/cta_vic.html\">这里</a> 找到。那非 CE 的 Timing，就是 IT。</p>\n<p>所以当显卡驱动选择了一个时序以后，就根据它是 CE 还是 IT 来决定默认是 Limited 还是 Full。但同时，显卡软件也允许用户自己选择颜色 range。那显示器是怎么知道显卡发送的到底是 Full range 还是 Limited range 呢？</p>\n<p>答案是，HDMI 里有传递元数据的 AVI InfoFrame。它里面可以指定，RGB 用的是 Full range 还是 Limited range；YCbCr 用的是 Full range 还是 Limited range。当显示器看到这个信息的时候，就知道不该用默认值去解析了。</p>\n<p>但是，并不是所有显示器都支持这个。所以，它还得先在 EDID 里通过 VCDB 来声明，它的 RGB 或 YCbCr，是否允许通过 AVI InfoFrame 指定 range。</p>\n<h2 id=\"解决方法\">解决方法</h2>\n<p>根据这些信息，就能想到解决方法了：把固件里的 EDID 换掉，全用 IT timing（比如用 CVT-RB），这样默认就是 Full range 了。这样确实工作了。</p>\n<p>但是，实践中，又遇到了新问题：我的<a href=\"../../../../../misc/2026/09/11/classroom-routing/\">使用场景</a>里，采集卡和教室的投影仪通过一个 HDMI Splitter 连到电脑上，此时就得兼顾采集卡的情况，而采集卡用的是 CE Timing，比如 VIC 97。结果就是电脑通过 HDMI Splitter 这么一通接了以后，又回到 Limited range 了。</p>\n<p>那怎么办呢？如果采集卡能自己识别输入是 Full range 还是 Limited range，然后进行相对应的处理就好了。</p>\n<p>怎么识别呢？刚才提到，AVI InfoFrame 里会携带这个信息。所以就修改 EDID，在 VCDB 里设置 QS=1，这样 AVI InfoFrame 里就会出现指定 Full range 还是 Limited range 的信息。然后经过逆向，发现 MS2130S 会在寄存器 0x3c4a 里记录这个信息，这样就可以自动检测了。</p>\n<p>怎么处理呢？之前，我的做法是在 OBS 里去 Apply LUT，实现 Limited range 到 Full 的反向映射。但是，如果从 Limited range 的输入切换到 Full range，就得调整 OBS，很麻烦。</p>\n<p>于是我就想到，利用已有的 luma processing 和 chroma processing 的 pipeline。根据之前的分析，已知这两个 pipeline 做的事情是：</p>\n<ul>\n<li>luma processing：<code>clip(clip(Y + fc90) * fc91/128)</code></li>\n<li>chroma processing：<code>clip(rotate(ΔR, ΔB) * fc92/128)</code></li>\n</ul>\n<p>如果想要实现 Limited range 到 Full range 的映射，也就是 16-235 线性映射到 0-255，只需要：</p>\n<ul>\n<li>0xfc90 设为 0xf0，对应 -16</li>\n<li>0xfc91 设为 0x95，对应 255/219</li>\n<li>0xfc92 设为 0x95，同样对应 255/219</li>\n<li>最后把 0xfc8f 和 0xfc8e 都设为 0x00，打开 processing pipeline</li>\n</ul>\n<p>最终的结果是，在 YCbCr 上的变换，对应到 RGB 上，正好就是 Limited range 到 Full range 的映射。这样就不用改 OBS 的 Filter，也可以达到一样的效果。</p>\n<p>上面这些逻辑，如果写到固件里，当然是最好的，但还得避免 UVC brightness 等设置把这些寄存器的值覆盖掉；不过固件毕竟不是源码，大范围的汇编改动还是比较危险。</p>\n<p>最后的解决办法是，写了一个程序，通过 hidapi 去轮询 0x3c4a 寄存器，根据它是 Full range 还是 Limited range 来调整内部的寄存器，这样无论输入是哪种 range，都可以采集到正确的颜色了。此外，我还在 EDID 里把 YCbCr 都去掉了，只保留了 RGB 的支持，这样就只需要考虑一种转换。</p>\n<p>这样，无论是 MateBookPro，还是跑了 Windows 的机器，都可以准确地采集了。当然，还有一个遗留问题，就是苹果电脑，它依然会出现偏色的问题，具体的原因还没能找到。</p>","date_modified":"2026-11-13T00:00:00+00:00","date_published":"2026-11-13T00:00:00+00:00","id":"https://jia.je/hardware/2026/11/13/fix-ugreen-95348-2/","image":null,"tags":["capture","hardware","hdmi","ugreen"],"title":"修复绿联 UG307-95348 HDMI 采集卡颜色问题（二）","url":"https://jia.je/hardware/2026/11/13/fix-ugreen-95348-2/"},{"authors":[],"content_html":"<h1 id=\"升级-ceph-集群到-20-tentacle-版本\">升级 Ceph 集群到 20 Tentacle 版本</h1>\n<h2 id=\"背景\">背景</h2>\n<p>之前一直用 Cephadm 维护了一个 Ceph 集群，作为一个 K8s 集群的存储，通过 Rook External Ceph Cluster 来维护。Ceph 出了一个比较严重的 <a href=\"https://docs.ceph.com/en/latest/security/CVE-2025-30156/\">CVE-2025-30156</a>，需要把已有的 key 都 rotate 一遍，这里把这个过程记录一下。</p>\n<!-- more -->\n\n<h2 id=\"升级过程\">升级过程</h2>\n<p>最开始的时候，Ceph 版本是 19.2.3，Rook 版本是 1.18.11，此时这个 Ceph 版本是有安全问题的，需要升级，核心就是上面的那个 CVE：原来的认证用的是 aes 算法，无论是客户端还是 Ceph 自己的各服务。但是，这个算法的实现有安全问题，居然用固定的 IV，还是 AES-128-CBC，所以需要换到新的 aes256k 上，然后把原来的 key 都淘汰掉。Ceph 的各服务和 Rook 自己的客户端都好说，升级版本以后，就可以替换为新的 key，麻烦的是，很多 CephFS 是通过 Linux 内核挂载的，而 Linux 内核直到 7.0 才支持 aes256k。旧版本内核，如果指定 aes256k 的 secret，会说 secret length 错误，无法挂载。</p>\n<p>所以第一步，就是给各虚拟机都升级到了 7.0 的内核：trixie 和 trixie-security 都不够新，所以就用了 trixie-backports 的 7.2 内核。</p>\n<p>升级完 Linux 内核后，就可以开始动手升级 Ceph 了，首先用 cephadm 升级 Ceph 到 20.2.5：</p>\n<div class=\"language-shell highlight\"><pre><span></span><code><span id=\"__span-0-1\"><a id=\"__codelineno-0-1\" name=\"__codelineno-0-1\" href=\"#__codelineno-0-1\"></a>ceph<span class=\"w\"> </span>orch<span class=\"w\"> </span>upgrade<span class=\"w\"> </span>start<span class=\"w\"> </span>--image<span class=\"w\"> </span>quay.io/ceph/ceph:v20.2.5\n</span></code></pre></div>\n<p>经过一段时间的等待，Ceph 的各服务都升级到了 20.2.5，并且 Cephadm 自动把服务用到的各种 key 都替换成了 aes256k。但是，还是有一些 key 需要手动操作，比如 client.admin。参考 <a href=\"https://docs.ceph.com/en/latest/rados/configuration/auth-config-ref/#cephx-upgrade\">Upgrading and Rotating CephX Keys</a>，把 client.admin 的 key 给 rotate 掉：</p>\n<div class=\"language-shell highlight\"><pre><span></span><code><span id=\"__span-1-1\"><a id=\"__codelineno-1-1\" name=\"__codelineno-1-1\" href=\"#__codelineno-1-1\"></a>ceph<span class=\"w\"> </span>mon<span class=\"w\"> </span><span class=\"nb\">set</span><span class=\"w\"> </span>auth_allowed_ciphers<span class=\"w\"> </span>aes,aes256k\n</span><span id=\"__span-1-2\"><a id=\"__codelineno-1-2\" name=\"__codelineno-1-2\" href=\"#__codelineno-1-2\"></a>ceph<span class=\"w\"> </span>mon<span class=\"w\"> </span><span class=\"nb\">set</span><span class=\"w\"> </span>auth_preferred_cipher<span class=\"w\"> </span>aes256k\n</span><span id=\"__span-1-3\"><a id=\"__codelineno-1-3\" name=\"__codelineno-1-3\" href=\"#__codelineno-1-3\"></a>ceph<span class=\"w\"> </span>auth<span class=\"w\"> </span>get-or-create<span class=\"w\"> </span>client.admin-backup<span class=\"w\"> </span>mon<span class=\"w\"> </span><span class=\"s2\">\"allow *\"</span><span class=\"w\"> </span><span class=\"p\">|</span><span class=\"w\"> </span>tee<span class=\"w\"> </span>./client.admin-backup.keyring\n</span><span id=\"__span-1-4\"><a id=\"__codelineno-1-4\" name=\"__codelineno-1-4\" href=\"#__codelineno-1-4\"></a>ceph<span class=\"w\"> </span>-n<span class=\"w\"> </span>client.admin-backup<span class=\"w\"> </span>-k<span class=\"w\"> </span>./client.admin-backup.keyring<span class=\"w\"> </span>auth<span class=\"w\"> </span>ls\n</span><span id=\"__span-1-5\"><a id=\"__codelineno-1-5\" name=\"__codelineno-1-5\" href=\"#__codelineno-1-5\"></a>ceph<span class=\"w\"> </span>auth<span class=\"w\"> </span>rotate<span class=\"w\"> </span>--key-type<span class=\"o\">=</span>aes256k<span class=\"w\"> </span>client.admin<span class=\"w\"> </span><span class=\"p\">|</span><span class=\"w\"> </span>tee<span class=\"w\"> </span>./client.admin.keyring\n</span></code></pre></div>\n<p>对于 Cephadm，修改一台机器上的 <code>/etc/ceph/ceph.client.admin.keyring</code>，把里面的 admin key 换了，然后分发到其他机器上：</p>\n<div class=\"language-shell highlight\"><pre><span></span><code><span id=\"__span-2-1\"><a id=\"__codelineno-2-1\" name=\"__codelineno-2-1\" href=\"#__codelineno-2-1\"></a>ceph<span class=\"w\"> </span>orch<span class=\"w\"> </span>client-keyring<span class=\"w\"> </span><span class=\"nb\">set</span><span class=\"w\"> </span>client.admin<span class=\"w\"> </span><span class=\"s2\">\"label:_admin\"</span>\n</span></code></pre></div>\n<p>剩下的需要 Rotate 的 key，就都是 Rook 需要的了：</p>\n<ul>\n<li>client.csi-cephfs-node</li>\n<li>client.csi-cephfs-provisioner</li>\n<li>client.csi-rbd-node</li>\n<li>client.csi-rbd-provisioner</li>\n<li>client.healthchecker</li>\n</ul>\n<p>这些 Key 都保存在 rook ceph 用于 external cluster 的 namespace 里的各 secret，根据名字很容易找到。我把 Rook 升级到 v1.21.2 后，直接在 Headlamp 里手动做的替换，虽然官方也给了脚本，但是脚本有一些依赖装起来比较麻烦，有 APT 的依赖问题。以 client.csi-cephfs-node 为例，其实就是：</p>\n<div class=\"language-shell highlight\"><pre><span></span><code><span id=\"__span-3-1\"><a id=\"__codelineno-3-1\" name=\"__codelineno-3-1\" href=\"#__codelineno-3-1\"></a>ceph<span class=\"w\"> </span>auth<span class=\"w\"> </span>rotate<span class=\"w\"> </span>--key-type<span class=\"o\">=</span>aes256k<span class=\"w\"> </span>client.csi-cephfs-node\n</span></code></pre></div>\n<p>然后把新的 key，替换掉 rook-csi-cephfs-node Secret 里面的 adminKey。其他几个也是类似的。</p>\n<p>把所有的 key 都 rotate 成 aes256k 后（通过看 key 的长度能看出是 aes 还是 aes256k），确认旧的 key 没有继续在使用（特别注意有没有正在用旧 key 挂载的 CephFS），禁用旧的 aes key 的使用：</p>\n<div class=\"language-shell highlight\"><pre><span></span><code><span id=\"__span-4-1\"><a id=\"__codelineno-4-1\" name=\"__codelineno-4-1\" href=\"#__codelineno-4-1\"></a>ceph<span class=\"w\"> </span>config<span class=\"w\"> </span><span class=\"nb\">set</span><span class=\"w\"> </span>mon<span class=\"w\"> </span><span class=\"s1\">'mon auth allow insecure key'</span><span class=\"w\"> </span><span class=\"nb\">false</span>\n</span><span id=\"__span-4-2\"><a id=\"__codelineno-4-2\" name=\"__codelineno-4-2\" href=\"#__codelineno-4-2\"></a>ceph<span class=\"w\"> </span>mon<span class=\"w\"> </span><span class=\"nb\">set</span><span class=\"w\"> </span>auth_service_cipher<span class=\"w\"> </span>aes256k\n</span><span id=\"__span-4-3\"><a id=\"__codelineno-4-3\" name=\"__codelineno-4-3\" href=\"#__codelineno-4-3\"></a>ceph<span class=\"w\"> </span>auth<span class=\"w\"> </span>wipe-rotating-service-keys\n</span><span id=\"__span-4-4\"><a id=\"__codelineno-4-4\" name=\"__codelineno-4-4\" href=\"#__codelineno-4-4\"></a>ceph<span class=\"w\"> </span>mon<span class=\"w\"> </span><span class=\"nb\">set</span><span class=\"w\"> </span>auth_allowed_ciphers<span class=\"w\"> </span>aes256k\n</span></code></pre></div>\n<p>最后，ceph health 没有任何关于 insecure key 的 warning，就算迁移完成。</p>\n<h2 id=\"参考文档\">参考文档</h2>\n<ul>\n<li><a href=\"https://docs.ceph.com/en/latest/rados/configuration/auth-config-ref/#cephx-upgrade\">Upgrading and Rotating CephX Keys</a></li>\n<li><a href=\"https://docs.ceph.com/en/latest/security/CVE-2025-30156/\">CVE-2025-30156: AES-CBC misuse in CephX facilitating authentication bypass</a></li>\n<li><a href=\"https://github.com/rook/rook/issues/18203\">Ceph CVE notice and Rook advisory</a></li>\n</ul>","date_modified":"2026-11-07T00:00:00+00:00","date_published":"2026-11-07T00:00:00+00:00","id":"https://jia.je/devops/2026/11/07/upgrade-ceph-to-20/","image":null,"tags":["ceph","devops","rook"],"title":"升级 Ceph 集群到 20 Tentacle 版本","url":"https://jia.je/devops/2026/11/07/upgrade-ceph-to-20/"},{"authors":[],"content_html":"<h1 id=\"用-xrdp--x11-转发实现带音频的图形界面转发\">用 XRDP + X11 转发实现带音频的图形界面转发</h1>\n<h2 id=\"背景\">背景</h2>\n<p>最近遇到一个需求，在机器 A 上跑一个图形界面程序，但因为是远程访问，所以传统的办法就是开个 X11 Forwarding，或者跑个 VNC/RDP Server。但我有音频转发的需求，本地是 macOS，又不好在机器 A 上装 XRDP+桌面环境，于是在机器 B 上跑 XRDP Server，在机器 A 上通过 X11 Forwarding + Unix Socket Forwarding 实现图形界面和音频在机器 B 上的播放，再通过 RDP 客户端在 macOS 上实现带音频的图形界面浏览。</p>\n<!-- more -->\n\n<h2 id=\"具体实现方法\">具体实现方法</h2>\n<p>具体实现方法不难，主要是在机器 B 上做一些配置：</p>\n<ol>\n<li>安装 XRDP，配置桌面环境，我用的是 Xfce4</li>\n<li>安装 pipewire-module-xrdp，关闭 pulseaudio 服务，改为 pipewire + pipewire-pulse + wireplumber</li>\n<li>带 X11 Forwarding 连接到机器 A，同时通过 Unix Socket 转发 pulseaudio 的 Unix Socket：<code>DISPLAY=XRDP_DESKTOP_HERE ssh -X -Y -R /run/user/UID_A_HERE/pulse/native:/run/user/UID_B_HERE/pulse/native host_a</code></li>\n</ol>\n<p>然后在 SSH Session 里跑带图形界面的程序即可，它就会通过 ssh 转发的 X11 在 XRDP 的 DISPLAY 上显示，再通过 pulse/native 的 Unix Socket 播放音频。</p>\n<p>最后，通过 RDP Client（Windows App）连接到机器 B，就可以在看到图形界面的同时，也有正确的音频了。</p>","date_modified":"2026-11-03T00:00:00+00:00","date_published":"2026-11-03T00:00:00+00:00","id":"https://jia.je/software/2026/11/03/xrdp-x11-forwarding/","image":null,"tags":["forwarding","linux","rdp","software","x11","xrdp"],"title":"用 XRDP + X11 转发实现带音频的图形界面转发","url":"https://jia.je/software/2026/11/03/xrdp-x11-forwarding/"},{"authors":[],"content_html":"<h1 id=\"用-files-api-减少图片体积导致的-ttft-膨胀\">用 Files API 减少图片体积导致的 TTFT 膨胀</h1>\n<h2 id=\"背景\">背景</h2>\n<p>最近我经常用 DeepSeek-V4.1-Flash 模型读图。由于每次请求都要传完整上下文，随着上下文里的图片越来越多，上传图片所花的时间很快就成了 TTFT 的主要瓶颈；如果走的是 OpenCode Go，甚至动辄要几分钟。为了解决这个问题，可以用 Files API 提前把图片上传到 DeepSeek，然后在上下文里直接用 id 引用文件。为此，我顺手 Vibe 了一个 <a href=\"https://github.com/jiegec/pi-files-api\">pi-files-api</a>/<a href=\"https://github.com/jiegec/opencode-files-api\">opencode-files-api</a> 插件，给 Pi Agent 和 OpenCode 都加上了这个能力。</p>\n<!-- more -->\n\n<h2 id=\"具体现象\">具体现象</h2>\n<p>我最近发现一个现象：在一些会话里，TTFT 稳定地偏高，而且越来越高，从 10s、12s 一路上涨，有时甚至到几分钟的量级，而这些会话都包含大量的图片读取。一开始我以为是服务端的问题，后来通过交流和分析才发现，图片在每次请求时都会被重新发送给后端；随着读取的图片不断累积，TTFT 里的大部分时间都耗在了上传图片上。</p>\n<p>一开始，我还寄希望于有状态的 OpenAI Responses API：每次只发送相对上一次请求的增量，从而避免图片的重复上传。然而 DeepSeek 目前还没有实现这个功能，所以只能用 Files API 了。</p>\n<h2 id=\"files-api\">Files API</h2>\n<p>可以把 Files API 理解为一个临时的网盘，它支持上传、列举、删除和查询，有 OpenAI 和 Anthropic 两个版本，不过功能大同小异。在这个临时网盘里，每个文件都有唯一的 id，可以出现在 chat completions/responses/anthropic messages 请求体中，用来代替实际的图片内容。</p>\n<p>因此，如果 Agent 懂得使用 Files API，先上传图片，再用 file id 填充请求体，就可以解决上述 TTFT 暴增的问题。DeepSeek Harness 是支持的，但前提是使用第一方 API；像我这样通过 AxonHub 统一管理 API key 的情况，它就没法用上这个 Files API 了。</p>\n<p>另外，我日常使用的 Pi Agent 也没有做这个优化。不过在 AI 时代，做这样一个优化，也就是写几句 Prompt、写个插件的事情。</p>\n<h2 id=\"pi-files-api\">pi-files-api</h2>\n<p>最终，我快速 Vibe 出了一个插件 <a href=\"https://github.com/jiegec/pi-files-api\">pi-files-api</a>：它从 models.json 读取配置，替换上下文里的图片 base64，上传到指定的 Files API Endpoint，然后用 file id 替代图片内容；插件内部还维护了一份 sha256 到 file id 的映射。后续又把它移植到了 OpenCode 上：<a href=\"https://github.com/jiegec/opencode-files-api\">opencode-files-api</a>。</p>\n<p>当然，目前 AxonHub 还不支持代理 Files API，所以我只能被迫在本地给 Pi 配置 DeepSeek 的 API key：先通过 api.deepseek.com 上传图片，再通过 AxonHub 发送实际的请求体，非常不优雅。希望 AxonHub 后续能增加对 Files API 的支持，不过这也带来一个问题：切换 API 上游时，Files 不会跟着迁移，换了一个供应商以后，原来的 file id 就失效了。这个问题我还没想好怎么办，只能先曲线救国一下。</p>","date_modified":"2026-10-12T00:00:00+00:00","date_published":"2026-10-12T00:00:00+00:00","id":"https://jia.je/software/2026/10/12/use-files-api-to-reduce-ttft/","image":null,"tags":["api","axonhub","deepseek","llm","software"],"title":"用 Files API 减少图片体积导致的 TTFT 膨胀","url":"https://jia.je/software/2026/10/12/use-files-api-to-reduce-ttft/"},{"authors":[],"content_html":"<h1 id=\"替换自制服务器上的-48v-直流电源\">替换自制服务器上的 48V 直流电源</h1>\n<h2 id=\"背景\">背景</h2>\n<p>又到了新学期，计算机组成原理的实验又轰轰烈烈地开始了，但实验平台背后的 FPGA 集群，却出现了一台自制服务器不工作的问题，通过替换 48V 直流电源解决了。</p>\n<!-- more -->\n\n<h2 id=\"自制服务器\">自制服务器</h2>\n<p>说是服务器，但实际上，这个服务器是借用了机架式服务器的外壳，把里面改造成了一个 FPGA 集群。它通过一个电源把 220V 市电转成 48V 直流电源，然后给三个 10 口 PoE 交换机供电，然后每个 PoE 交换机再通过 PoE 给 8 个 FPGA 开发板供电。此外，再通过一个 48V 到 12V 的 DCDC 直流电源，给几个风扇供电。这样，一个自制服务器里，就可以承载 24 个 FPGA 开发板，再通过多个自制服务器组成 FPGA 集群。</p>\n<p>交换机之间，采用菊花链的方式连接，最后连一根网线到机柜上的交换机。</p>\n<h2 id=\"问题定位\">问题定位</h2>\n<p>问题出在，其中一台自制服务器通电后没有反应。把自制服务器从机柜上拆下来，用万用表测试，最终的结论是：48V 电源坏了，输出的两个直流端子之间的电压为零，电源上的灯也没有亮。后续把电源拆出来看了看，没找到特别明显的出问题的部件。</p>\n<h2 id=\"修复\">修复</h2>\n<p>修复也很简单：找到了一个同型号的备用电源，一通拆卸，再按照原来的方式装回来就可以。由于这个 48V 电源的输出就是两个带有螺丝的端子，所以要把各路电源（三个交换机、一路 DCDC）的电源线的正和负分别压紧到对应的端子上，防止虚接发热。</p>","date_modified":"2026-10-09T00:00:00+00:00","date_published":"2026-10-09T00:00:00+00:00","id":"https://jia.je/hardware/2026/10/09/replace-48v-power/","image":null,"tags":["hardware","power","server"],"title":"替换自制服务器上的 48V 直流电源","url":"https://jia.je/hardware/2026/10/09/replace-48v-power/"},{"authors":[],"content_html":"<h1 id=\"探究一个-usb-type-c-拓展坞的硬件实现\">探究一个 USB Type-C 拓展坞的硬件实现</h1>\n<h2 id=\"背景\">背景</h2>\n<p>最近在高强度使用 HDMI 和 DP 做视频输出，但在使用的时候遇到了各种细节问题，所以就研究整个链路上到底发生了哪些事情，在这个过程中，研究了一下手上的 Biaze KZ11 这款 Type-C 拓展坞，看看它内部有哪些芯片，又是怎样实现拓展坞的功能的。</p>\n<!-- more -->\n\n<h2 id=\"拓展坞基本信息\">拓展坞基本信息</h2>\n<p>首先介绍一下这款拓展坞的基本信息，从购买页面可以看到：</p>\n<ul>\n<li>接口上，有三个 USB 3.0（5 Gbps），一个 TF/SD 读卡槽，一个 HDMI，一个 VGA，一个 3.5mm TRS 音频输出，一个千兆以太网口，还有一个 Type-C PD 供电</li>\n<li>采用了 RTL8153、GL3224、VL103、VL817、AG6320 芯片</li>\n<li>HDMI 最高支持 4K 30Hz，VGA 最高支持 1080P 60Hz</li>\n</ul>\n<p>当然，本博客并不是购物推荐，只是因为恰好手上有这么一个拓展坞，并且把它用的芯片给了出来，所以才方便了我做分析。</p>\n<h2 id=\"初步分析\">初步分析</h2>\n<p>既然给出了芯片型号，我就去调查了一下，这些芯片都是做什么的：</p>\n<ul>\n<li><a href=\"https://www.olimex.com/Products/USB-Modules/Ethernet/USB-GIGABIT/resources/rtl8153.pdf\">RTL8153</a>：USB 3.0 的千兆以太网控制器</li>\n<li><a href=\"https://datasheet.lcsc.com/datasheet/pdf/5c4f88684f5251afc47f0c71b7afbb47.pdf?productCode=C157357\">GL3224</a>：USB 3.2 Gen 1 的读卡器，用于 TF/SD 卡读取</li>\n<li><a href=\"http://www.usbtech.net/upload/portal/20210128/5fd1d287e44435e7296e05398fa0210c.pdf\">VL103</a>：Type-C DP Alt-Mode 和 PD 3.0 控制器</li>\n<li><a href=\"https://datasheet.lcsc.com/datasheet/pdf/2c50386e71e0024e256f1a4e608872ad.pdf?productCode=C29780427\">VL817</a>：USB 3.1 Gen 1 (5Gbps) 的 Hub，最多接四个下游设备</li>\n<li><a href=\"https://img.jdzj.com/UserDocument/mallpic/QQ1659747718/dn/zl8535.pdf\">AG6320</a>：把 DP 转化为 HDMI 或者 VGA 信号，同时音频通过 I2S 接口输出，DP 运行在 5.40 Gbps HBR2 速率下，两个 lane 带宽一共是 10.80 Gbps，考虑编码损失还有 <code>10.80*8/10=8.64</code> Gbps，所以最高 4K 30Hz 4:4:4 8bpc，它需要的带宽是 <code>3840*2160*30*24=5.97</code> Gbps，算上消隐区就是 <code>4400*2250*30*24=7.13</code> Gbps</li>\n</ul>\n<p>于是我就想，既然 Type-C 拓展坞连电脑只有一个 Type-C，这个 Type-C 只能连一个设备，而下游有这么多设备：RTL8153，GL3224、VL103，都需要接到 USB 总线上，需要 VL817 来拓展，此外还有三个额外的 USB 口，那就至少有六个设备了，一个 VL817 不够，那就得级联一下：</p>\n<pre class=\"mermaid\"><code>flowchart LR\n    Host --&gt;|Type-C| VL817_1[VL817 #1]\n    VL817_1 --&gt; RTL8153 --&gt; ETH\n    VL817_1 --&gt; GL3224 --&gt; TF/SD\n    VL817_1 --&gt; VL103 --&gt; DP --&gt; AG6320 --&gt; HDMI\n    AG6320 --&gt; VGA\n    AG6320 --&gt; I2S\n    VL103 --&gt; PD[Type-C PD 3.0]\n    VL817_1 --&gt; VL817_2[VL817 #2]\n    VL817_2 --&gt; Port1[USB 3.0 Port #1]\n    VL817_2 --&gt; Port2[USB 3.0 Port #2]\n    VL817_2 --&gt; Port3[USB 3.0 Port #3]</code></pre>\n<p>这里我觉得，既然 AG6320 输入是 DP，然后 VL103 是 DP Alt-mode 芯片，那就应该 AG6320 的输入来自于 VL103，就画出了上面的拓扑。看起来很合理，但实际上有问题：</p>\n<ul>\n<li>VL817 是数据的 Hub，它能支持 PD 3.0 的高功率吗？</li>\n<li>VL817 #2 只有三个下游设备，理论上可以再来一个 USB 3.0 Port，为啥只用了三个？</li>\n</ul>\n<p>所以这个拓扑肯定不对，PD 芯片应该是直接接到电脑侧的，其他都是传数据的芯片，不需要也不应该接那么高功率的电源。这就给出了第二版拓扑：</p>\n<pre class=\"mermaid\"><code>flowchart LR\n    Host --&gt;|Type-C| VL103\n    VL103 --&gt; USB --&gt; VL817_1[VL817 #1]\n    VL817_1 --&gt; RTL8153 --&gt; ETH\n    VL817_1 --&gt; GL3224 --&gt; TF/SD\n    VL103 --&gt; DP --&gt; AG6320 --&gt; HDMI\n    AG6320 --&gt; VGA\n    AG6320 --&gt; I2S\n    VL103 --&gt; PD[Type-C PD 3.0]\n    VL817_1 --&gt; VL817_2[VL817 #2]\n    VL817_2 --&gt; Port1[USB 3.0 Port #1]\n    VL817_2 --&gt; Port2[USB 3.0 Port #2]\n    VL817_2 --&gt; Port3[USB 3.0 Port #3]</code></pre>\n<p>但这依然很奇怪：VL817 #1 和 VL817 #2 各有一个 Port 是空的，这不是浪费了吗？说明这个拓扑依然不对。</p>\n<h2 id=\"usb-拓扑分析\">USB 拓扑分析</h2>\n<p>上面都是从芯片的功能来硬推，推不出来合理的拓扑，那就说明我对芯片的功能的理解还是有所欠缺。那就从电脑这边来看，USB 总线上是个什么拓扑：</p>\n<p>首先，我能看到有一个 USB 3.0 的 Hub（2109:0817），下面出现的设备是：</p>\n<ul>\n<li>RTL8153 网卡</li>\n<li>USB 3.0 端口 #1</li>\n<li>USB 3.0 端口 #2</li>\n<li>USB 3.0 端口 #3</li>\n</ul>\n<p>这意味着，RTL8153 网卡是和三个 USB 3.0 端口挂在同一个 Hub 下的，猜测就是 VL817。此外，还有一个 USB 2.0 的 Hub（2109:2817），下面出现的设备是：</p>\n<ul>\n<li>另一个 USB 2.0 的 Hub（Terminus，1a40:0801，推测是 <a href=\"https://www.terminus.com.tw/en/product/series_one/fe_8_1.html\">FE8.1 芯片</a>）</li>\n<li>USB Billboard Device（2109:8888）</li>\n<li>USB 3.0 端口 #1 的 USB 2.0</li>\n<li>USB 3.0 端口 #2 的 USB 2.0</li>\n<li>USB 3.0 端口 #3 的 USB 2.0</li>\n</ul>\n<p>这个 Terminus 的 USB 2.0 Hub 下面，又挂载了两个设备：</p>\n<ul>\n<li>GL3224 读卡器</li>\n<li>USB C Video Adaptor（9636:9300），另一个 USB Billboard Device</li>\n</ul>\n<p>把这个 USB 总线拓扑画出来，就是：</p>\n<pre class=\"mermaid\"><code>flowchart LR\n    Host --&gt; USB3[USB 3.0 Hub 2109:0817]\n    USB3 --&gt; RTL8153 --&gt; ETH\n    USB3 --&gt; Port1[USB 3.0 Port #1]\n    USB3 --&gt; Port2[USB 3.0 Port #2]\n    USB3 --&gt; Port3[USB 3.0 Port #3]\n\n    Host --&gt; USB2[USB 2.0 Hub 2109:2817]\n    USB2 --&gt; Terminus[Terminus USB 2.0 Hub 1a40:0801]\n    USB2 --&gt; Billboard[USB Billboard Device 2109:8888]\n    USB2 --&gt; Port1_USB2[USB 3.0 Port #1 USB 2.0]\n    USB2 --&gt; Port2_USB2[USB 3.0 Port #2 USB 2.0]\n    USB2 --&gt; Port3_USB2[USB 3.0 Port #3 USB 2.0]\n    Terminus --&gt; GL3224 --&gt; TFSD[TF/SD Card]\n    Terminus --&gt; Adaptor[USB C Video Adaptor 9636:9300]</code></pre>\n<p>这个信息量很大，推翻了很多之前的分析：VL817 下游就是三个 USB 3.0，外加一个 RTL8153。然后 GL3224 是通过一个额外的 Terminus USB 2.0 Hub 接进来的，即使 GL3224 本身是一个 USB 3.2 Gen 1 的读卡器。同时为啥这个 USB 2.0 Hub 下面出现了五个设备？这个 USB Billboard Device 和 USB C Video Adaptor 又是哪来的？为啥要多加一个 Terminus USB 2.0 Hub？</p>\n<h2 id=\"推倒重来\">推倒重来</h2>\n<p>这说明一开始认为的“Type-C 只能连到一个芯片上，再分到不同的芯片”的假设是错误的。实际上，Type-C 是可以同时连到多个芯片上的：</p>\n<ul>\n<li>USB 2.0 的 D+/D-，用于 USB 2.0 总线</li>\n<li>USB 3.0 Type-C 的四个差分对，可以两个差分对用于 USB 3.0 总线，另外两个差分对用于 DP</li>\n<li>SBU 信号用于 DP 的 AUX</li>\n<li>电源和 CC，用于 USB PD</li>\n</ul>\n<p>也就是说，实际上，Host 通过一个 Type-C 端口，同时接到了 VL103、VL817 和 AG6320 上！也就是说，AG6320 并不是接到 VL103，而是直接从 Type-C 取走了两个差分对，来做 DP 输入，只是 SBU(AUX) 信号是先进入 VL103，再接到 AG6320，此外为了实现热插拔，AG6320 给出了 HPD 信号给 VL103；VL103 也不负责 USB 3.0，它只是负责电源、CC 协商和 DP Alt-mode，同时还透传了 USB 2.0；VL817 虽然是 USB 3.0 Hub，但它其实就是一个 USB 3.0 Hub 和一个 USB 2.0 Hub，输出是四个 USB 3.0 和四个 USB 2.0。这已经基本解释了大部分问题，还差最后一点：</p>\n<p>VL817 只有四个端口，那么，它 USB 3.0 Hub 下四个设备、USB 2.0 Hub 下五个设备都是怎么来的呢？</p>\n<p>注意到外接的 USB 3.0 端口，它也是 3.0 和 2.0 兼具的，而且得是同一个 Port，所以 VL817 前三个 Port 就是 USB 3.0 和 2.0 同时连到外接 USB 端口上。那只剩下一个 Port 了，这个 Port 上又需要接 RTL8153，又需要接 Terminus USB 2.0 Hub，此外还有一个 USB 2.0 的 Billboard 2109:8888 设备，这哪接的下来？</p>\n<p>答案是：最后一个 Port，把 3.0 部分和 2.0 部分分开：3.0 接 RTL8153，2.0 接 Terminus USB 2.0 Hub。实际上，从 USB 总线枚举上来看，这两个设备对应的 Port ID 是一样的。而那个 2109:8888 Billboard 设备，只是 VL817 自己枚举出来的设备，并没有实体。</p>\n<p>至于 USB C Video Adaptor 9636:9300 是怎么来的，其实就是 DP Alt-mode 的要求：VL103 同时也是一个 USB 2.0 Device，这个 Device 就是这个 USB C Video Adaptor，给 Host 汇报 Alt-mode 的一些信息。因为有这个 USB C Video Adaptor 和 GL3224 都需要接到 VL817 最后一个 USB 2.0 端口上，放不下，才又引入了一个 Terminus USB 2.0 Hub。</p>\n<p>至此，完整的硬件拓扑就比较清楚了：</p>\n<pre class=\"mermaid\"><code>flowchart LR\n    Host --&gt; PD --&gt; VL103\n    Host --&gt; SBU --&gt; VL103 --&gt;|AUX| AG6320\n    AG6320 --&gt;|HPD| VL103\n    Host --&gt; USB2[USB 2.0] --&gt; VL103 --&gt;|USB 2.0| VL817\n    Host --&gt; USB3[USB 3.0 2 lanes] --&gt; VL817\n    Host --&gt; DP[DP 2 lanes] --&gt; AG6320 --&gt; HDMI\n    AG6320 --&gt; VGA\n    AG6320 --&gt; I2S\n\n    VL817 --&gt; Port1[USB 3.0 Port 1, USB 3.0 + USB 2.0]\n    VL817 --&gt; Port2[USB 3.0 Port 2, USB 3.0 + USB 2.0]\n    VL817 --&gt; Port3[USB 3.0 Port 3, USB 3.0 + USB 2.0]\n    VL817 --&gt; Port4[Port 4]\n    Port4 --&gt;|USB 3.0| RTL8153 --&gt; ETH\n    Port4 --&gt;|USB 2.0| Terminus[Terminus USB 2.0 Hub]\n    VL817 --&gt; Billboard[Virtual Billboard Device 2109:8888]\n    Terminus --&gt; GL3224[GL3224 Card Reader 05e3:0749] --&gt; TFSD[TF/SD Card]\n    Terminus --&gt; Adaptor[USB C Video Adaptor 9636:9300 Billboard Device of VL103]</code></pre>\n<p>这样，VL817 的四个端口，无论是 USB 3.0 还是 USB 2.0，都物尽其用了，刚好把三个 USB 3.0 端口都用满了。多出来的 Terminus USB 2.0 Hub 的用途也解释清楚了。</p>\n<h2 id=\"附录分析绿联-cm478-15495\">附录：分析绿联 CM478-15495</h2>\n<p>顺带也分析了一下 <a href=\"https://www.lulian.cn/product/1432.html\">绿联 CM478-15495</a> 拓展坞的配置，它的参数如下：</p>\n<ul>\n<li>接口上，支持 USB3.0+USB2.0*2+PD+HDMI</li>\n<li>HDMI: 4K 30Hz, 1080P 120Hz</li>\n<li>PD 3.0 100W</li>\n</ul>\n<p>分析了一下 USB 拓扑，发现它的 USB 3.0 设备是直接通到电脑上的，没有经过 Hub；而它有一个 Genesys Logic 05e3:0608 的 4 口 USB 2.0 Hub（根据网上信息，猜测是 <a href=\"https://www.mouser.com/datasheet/2/306/Olimex_GL850G-3198672.pdf\">GL850G</a>），下面连了四个设备：</p>\n<ul>\n<li>DP Alt-mode 的 Billboard Device 343c:0000</li>\n<li>USB 2.0 端口 #1</li>\n<li>USB 2.0 端口 #2</li>\n<li>USB 3.0 端口的 USB 2.0</li>\n</ul>\n<p>那么 DP 则又是直接从 Type-C 拿走了两个差分对，然后 USB 3.0 端口是接了另外两个差分对。可见这又是一个物尽其用的例子。推测 CM478-15495 一种可能的拓扑：</p>\n<pre class=\"mermaid\"><code>flowchart LR\n    Host --&gt; PD --&gt; Unknown\n    Host --&gt; USB2[USB 2.0] --&gt; GL850G[GL850G USB 2.0 Hub 05e3:0608]\n    GL850G --&gt; Port2[USB 2.0 Port #1]\n    GL850G --&gt; Port3[USB 2.0 Port #2]\n    GL850G --&gt;|USB 2.0| Port1\n    GL850G --&gt; Port5[USB Billboard Device 343c:0000]\n    Host --&gt; USB3[USB 3.0 2 lanes] --&gt;|USB 3.0| Port1[USB 3.0 Port]\n    Host --&gt; DP[DP 2 lanes] --&gt; Unknown --&gt; HDMI</code></pre>\n<p>实际上，因为 CM478-15495 的 USB 3.0 端口是直接接到了电脑上，没有像 KZ11 那样过了一个 USB 3.1 Gen 1 的 VL817 Hub，在 macOS 实测速率可以协商到 10 Gbps，也就是 USB 3.1 Gen 2。同一个设备，插到 KZ11 的 USB 3.0 口上，就只有 5 Gbps 的速率了。</p>\n<h2 id=\"附录分析飞利浦-swr1607l93\">附录：分析飞利浦 SWR1607L/93</h2>\n<p>参数：</p>\n<ul>\n<li>3xUSB 3.0 5Gbps，其中两个是 Type-C，一个是 Type-A</li>\n<li>USB PD 100W</li>\n<li>HDMI 4K60Hz</li>\n</ul>\n<p>在系统里看到的是两个 Hub：</p>\n<ul>\n<li>USB 3.1 Hub 05e3:0626 5Gbps</li>\n<li>USB 2.1 Hub 05e3:0610 480Mbps</li>\n</ul>\n<p>目测又是 Genesys Logic 的 4 口 Hub，根据网上信息，猜测是 <a href=\"https://file.elecfans.com/web2/M00/70/41/poYBAGNKskWAA6yCABIBqv_sYz0403.pdf\">GL3523</a>，四口 USB 3.1 Gen 1 的 Hub。</p>\n<p>考虑到它只有 5Gbps，那么应该又是 Type-C 的两个 lane 通过 4 口 Hub 接出了三个 USB 3.0，剩下一个口有两种可能：一是留给 DP Alt-mode 的 Billboard Device，但实际上无论是否插 HDMI，都没有这个设备出现，或许是因为 DP Alt-mode 协商正常工作，所以 Billboard Device 没有出现，但实际上还是占用了一个口；二是它就是没有接任何设备。Hub 的 Port 4 对应 USB 3.0 Type-C 口，Port 3 对应 Type-C 旁边的 USB 3.0 Type-A 口，Port 2 则是最后一个离 Type-C 口最远的 USB 3.0 Type-C 口。</p>\n<p>另外两个 lane 则是给了 DP Alt-mode，这里的 HDMI 能跑到 4K 60Hz 4:4:4 8bpc，说明它的 DP 跑在了更高的速率：在 macOS 里看，它的 DP 运行在 8.10 Gbps (HBR3) 速率上，这样两个 lane 的总带宽就是 16.20 Gbps，考虑编码损失还有 <code>16.2*8/10=12.96</code> Gbps，足够 4K 60Hz 4:4:4 的 <code>3840*2160*60*24=11.94</code> Gbps 带宽，算上消隐区（需要消隐区比较少的时序），也就是 <code>4000*2205*60*24=12.70</code> Gbps。</p>\n<p>有意思的是，如果我直接用 Type-C 连显示器，那么它就可以用四个 lane 传 5.40 Gbps (HBR2) 速率，这样总速率达到了 21.60 Gbps，考虑编码损失还有 <code>21.60*8/10=17.28</code> Gbps，甚至可以 4K 75 Hz 4:4:4 8bpc，毕竟它只需要 <code>3840*2160*75*24=14.9</code> Gbps 带宽，算上消隐区，也就是 <code>4000*2205*75*24=15.88</code> Gbps。</p>\n<p>所以对于各种 Type-C 拓展坞来说，因为要保留 Type-C Hub 功能，所以最多有两个 lane 用于 DP，此时能跑到 4K 30Hz，还是 4K 60Hz，就取决于能跑到 HBR2 还是 HBR3 上。HBR2 就对应 4K 30Hz 4:4:4 8bpc 或者 4K 60Hz 4:2:0 8bpc，HBR3 就对应 4K 60Hz 4:4:4 8bpc（但需要消隐区比较少的时序，带宽特别紧张）。如果不走拓展坞，直连显示器，四个 lane 都可以用于 DP，此时即使是 HBR2，也能跑到 4K 75Hz 4:4:4 8bpc 上。</p>\n<p>也做了一个小实验，如果把显示器通过 Type-C 接到飞利浦 SWR1607L/93 的 USB 3.0 Type-C 口上，显示输出就不工作了，因为这个口过了一个 Hub，这个 Hub 不支持 DP Alt-mode。</p>\n<h2 id=\"附录分析绿联-cm136-70495\">附录：分析绿联 CM136-70495</h2>\n<p>也分析一下 绿联 CM136-70495 拓展坞的配置，它的参数如下：</p>\n<ul>\n<li>接口上，支持 USB3.0*3+PD+HDMI</li>\n<li>USB 3.0 5Gbps</li>\n<li>HDMI: 4K 60Hz</li>\n<li>PD 3.0 100W</li>\n</ul>\n<p>它的接口和上面的飞利浦 SWR1607L/93 一模一样，唯一的不同就是，绿联 CM136-70495 三个 USB 3.0 都是 Type-A，而飞利浦 SWR1607L/93 把其中一个换成了 Type-C。</p>\n<p>在系统里看到的是两个 Hub：</p>\n<ul>\n<li>USB 3.0 Hub 2109:0817 5Gbps</li>\n<li>USB 2.0 Hub 2109:2817 480Mbps</li>\n</ul>\n<p>看到这个熟悉的 VID/PID，不出意外，它用的和 Biaze KZ11 一样，也是 VL817，USB 3.1 Gen 1 5Gbps 的四口 Hub。然后三个 USB 3.0 Type-A 口都是挂在这个 VL817 四口 Hub 下。离 HDMI 最近的口是 Port 4，次近的是 Port 1，最远的是 Port 2。</p>\n<p>与飞利浦 SWR1607L/93 一样，它也能跑到 4K 60Hz 4:4:4 8bpc，在 macOS 里看，果然是 2 lane 的 HBR3。这次也没有 Billboard Device 出现。</p>\n<h2 id=\"附录同一个显示器一个拓展坞只能-4k-30hz另一个拓展坞可以-4k-60hz\">附录：同一个显示器，一个拓展坞只能 4K 30Hz，另一个拓展坞可以 4K 60Hz</h2>\n<p>不过在实践中，也遇到过特殊的情况：同一个 Crestron 420 显示器，连上述两个拓展坞出现了不同的现象：</p>\n<ul>\n<li>通过飞利浦 SWR1607L/93 接 Crestron 420，只能输出 4K 30Hz，没有 4K 60Hz 的选项</li>\n<li>通过绿联 CM136-70495 接 Crestron 420，则可以输出 4K 60Hz</li>\n</ul>\n<p>猜测是 EDID 的问题，由于 Crestron 420 的限制，HDMI 版本只有 1.4b，它的 4K 60Hz 是 4:2:0 的，但实际能否达到，还要看拓展坞这边能否提供正确的 EDID。首先是只能跑到 4K 30Hz 来自飞利浦 SWR1607L/93 的 EDID：</p>\n<div class=\"language-text highlight\"><pre><span></span><code><span id=\"__span-0-1\"><a id=\"__codelineno-0-1\" name=\"__codelineno-0-1\" href=\"#__codelineno-0-1\"></a>00ffffffffffff000ca9e10700000000041b010380502d800eee91a3544c99260f50542000000101010101010101010101010101010140d10080f0705a8020188a0020c23100001a023a801871382d40582c450020c23100001e000000fd00174c1e4b1e000a202020202020000000fc004372657374726f6e203432300a01fb02032172465f5e5d9004022309070783010000e2004f67030c001000003ce20e61023a801871382d40582c450020c23100001e04740030f2705a80b0588a0020c23100001e00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e5\n</span></code></pre></div>\n<p>接着是能跑到 4K 60Hz 来自绿联 CM136-70495 的 EDID：</p>\n<div class=\"language-text highlight\"><pre><span></span><code><span id=\"__span-1-1\"><a id=\"__codelineno-1-1\" name=\"__codelineno-1-1\" href=\"#__codelineno-1-1\"></a>00ffffffffffff000ca9e10700000000041b010380502d800eee91a3544c99260f50542000000101010101010101010101010101010104740030f2705a80b0588a0020c23100001e023a801871382d40582c450020c23100001e000000fc004372657374726f6e203432300a000000fd00174c1e4b1e000a202020202020010e02032970475f5e5d1005040223090707830100006d030c001000003c200060010203e30e6160e2004f0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000f7\n</span></code></pre></div>\n<h2 id=\"附录分析-biaze-zh395\">附录：分析 Biaze ZH395</h2>\n<p>参数：</p>\n<ul>\n<li>PD 100W</li>\n<li>HDMI 4K 30Hz</li>\n<li>5Gbps USB 3.0 Type-A 口</li>\n<li>一个 USB 2.0 Type-A 口</li>\n<li>一个 USB 2.0 Type-C 口</li>\n</ul>\n<p>看过前面这么多分析，基本可以推断出，它又是 Type-C 的两个 lane 直通 USB 3.0 Type-A 口，另外两个 lane 用于 DP Alt-mode，再来个 USB 2.0 的 Hub 214b:7260。虽然宣传的是 HDMI 4K 30Hz，但实际上能跑到 4K 60Hz，由于是 2 lane 的 HBR2，应该是 4:2:2 或者 4:2:0 而非 4:4:4，看起来有略微的模糊感。</p>\n<h2 id=\"附录分析绿联-cm511-45031\">附录：分析绿联 CM511-45031</h2>\n<p><a href=\"https://www.lulian.cn/product/1441.html\">CM511-45031 参数</a>:</p>\n<ul>\n<li>PD 3.0 100W</li>\n<li>HDMI 2.0 4K 60Hz</li>\n<li>3x USB 3.2 10 Gbps Type-A 口</li>\n<li>1x USB 3.2 10 Gbps Type-C 口</li>\n</ul>\n<p>实测 DP 能跑到 2 lane HBR3，因此可以轻松 4K 60Hz 4:4:4。USB 方面，有一个 USB 3.2 Hub GenesysLogic 05e3:0625 和一个 USB 2.1 Hub GenesysLogic 05e3:0610。这里的 USB 3.2 代表的其实是 USB 3.2 Gen 2，所以每个口都是 10Gbps。</p>\n<h2 id=\"附录同一个显示器不同拓展坞显示的频率选项不同\">附录：同一个显示器，不同拓展坞显示的频率选项不同</h2>\n<p>同一个 HKC 2755U 显示器，连上述拓展坞出现了不同的现象：</p>\n<ul>\n<li>通过飞利浦 SWR1607L/93 接 HKC T2755U，可以输出 4K 60Hz，无 50Hz 选项，同时还有 HDR 选项</li>\n<li>通过绿联 CM136-70495 接 HKC T2755U，可以输出 4K 60Hz/50Hz，同时还有 HDR 选项</li>\n<li>通过 Biaze ZH395 接 HKC T2755U，可以输出 4K 60Hz，无 50Hz 选项，同时还有 HDR 选项，但界面比较模糊，疑似 4:2:2 或 4:2:0，macOS 设置里显示的是分辨率列表，而不是像其他几个拓展坞那样，显示几种文字大小</li>\n<li>通过绿联 CM511-45031 接 HKC T2755U，可以输出 4K 60Hz/50Hz，同时还有 HDR 选项</li>\n</ul>\n<h2 id=\"附录其他常用拓展坞芯片\">附录：其他常用拓展坞芯片</h2>\n<ul>\n<li><a href=\"https://static.chipdip.ru/lib/923/DOC000923116.pdf\">AX88179</a>: USB 3.0 to 1000M Ethernet Controller</li>\n<li><a href=\"http://www.usbtech.net/upload/portal/20210129/273a4e5ddf8b65a319765aa6eb529a1d.pdf\">VL822</a>: USB 3.1 Gen 2 10Gbps 4-Port Hub Controller</li>\n<li><a href=\"https://www.tctek.cn/wp-content/uploads/2025/10/SW2505_Brief_V0.2-%E8%A7%84%E6%A0%BC%E4%B9%A6_compressed.pdf\">SW2505</a>: USB PD Controller</li>\n</ul>","date_modified":"2026-10-02T00:00:00+00:00","date_published":"2026-10-02T00:00:00+00:00","id":"https://jia.je/hardware/2026/10/02/type-c-dongle-analysis/","image":null,"tags":["biaze","dp","hardware","typec","usb"],"title":"探究一个 USB Type-C 拓展坞的硬件实现","url":"https://jia.je/hardware/2026/10/02/type-c-dongle-analysis/"},{"authors":[],"content_html":"<h1 id=\"把博客生成器从-mkdocs-迁移到-zensical\">把博客生成器从 Mkdocs 迁移到 Zensical</h1>\n<p>距离上一次 <a href=\"../../../../2023/07/15/migrate-from-hugo-to-mkdocs/\">从 Mkdocs 迁移到 Zensical</a> 已经过去了三年，这次 Zensical 终于是补齐了原来 Mkdocs 用到的大部分插件，所以就当小白鼠，把博客从 Mkdocs + Mkdocs-Material 迁移到了 Zensical。</p>\n<!-- more -->\n\n<p>这次迁移的背景，就是 Mkdocs-Material 团队对 Mkdocs 后续的更新计划不满，自己独立出来，RIIR 了一个尽量兼容 Mkdocs 生态的 Zensical。当然这个兼容不是 100% 的，所以我也在逐渐地做一些替换，从 <a href=\"/ctf-writeups/\">ctf-writeups</a> 开始，到 <a href=\"/cpu/\">cpu</a>，再到博客主站，未来等 i18n 插件到位了，再迁移 <a href=\"/kb/\">kb</a> 等等。其实用起来也没啥区别，连配置文件都不用改，然后就是构建速度确实快了很多，之前 mkdocs build 一次要好几十秒，zensical 明显更快。插件方面，我也自己移植了一个 <a href=\"https://github.com/jiegec/zensical-wavedrom-plugin\">zensical-wavedrom-plugin</a> 用来渲染 wavedrom 波形图。</p>\n<p>回顾历史，本博客已经做了好几次迁移：</p>\n<ul>\n<li><a href=\"../../../../2019/05/02/migrate-from-jekyll-to-hugo/\">2019 年，从 Jekyll 到 Hugo</a></li>\n<li><a href=\"../../../../2023/07/15/migrate-from-hugo-to-mkdocs/\">2023 年，从 Hugo 到 Mkdocs</a></li>\n<li>现在 2026 年，从 Mkdocs 到 Zensical</li>\n</ul>\n<p>迁移的基本动力，要么是原来的生成器太慢了，要么就是有一些硬伤。不知道几年后，会不会再迁移到新的技术栈呢。</p>","date_modified":"2026-09-30T00:00:00+00:00","date_published":"2026-09-30T00:00:00+00:00","id":"https://jia.je/meta/2026/09/30/migrate-from-mkdocs-to-zensical/","image":null,"tags":["meta","site"],"title":"把博客生成器从 Mkdocs 迁移到 Zensical","url":"https://jia.je/meta/2026/09/30/migrate-from-mkdocs-to-zensical/"},{"authors":[],"content_html":"<h1 id=\"one-cpu-atomic-instruction-one-packaging-infinite-loop-the-story-of-the-lost-update-on-la664\">One CPU Atomic Instruction, One Packaging Infinite Loop: The Story of the Lost Update on LA664</h1>\n<p><a href=\"../loongson-cpu-erratum/\">中文版本</a></p>\n<h2 id=\"tldr\">TL;DR</h2>\n<p>In February 2026, <a href=\"https://github.com/shankerwangmiao\">Wang Miao</a> ran into something strange while packaging normaliz for Debian on a LoongArch server: the math software's built-in test kept timing out, stuck in an infinite loop that it could not escape. Following the code, the problem pointed to a very ordinary operation: OpenMP's <code>#pragma omp atomic</code> accumulating into a shared variable. The loop's exit condition required the accumulated value to equal a certain number, but the accumulated result was always less than that number, causing the infinite loop. Because the program was large and the code complex, we never managed to reduce it to a minimal example a human could understand, so the matter was shelved.</p>\n<p>Half a year later, in August, Wang Miao came to me again, wanting to pick it back up. This time we took a different approach: instead of having a human locate the problem, we let AI find a minimal reproduction, with the human directing the AI's investigation. About two days later, we had a stable reproducer, and only then discovered the root cause: the CPU's atomic add instruction occasionally fails to be atomic. This meant we had found a new CPU erratum, and after Loongson learned of it, only two weeks passed before they found a fix with almost no performance loss and provided us with test firmware. We confirmed that the test firmware resolves the issue, and Loongson told us the firmware is expected to be released before National Day (October 1), at which point readers will be able to upgrade their firmware to fix the problem.</p>\n<!-- more -->\n\n<p>Now let us tell the whole story from beginning to end.</p>\n<h2 id=\"origins\">Origins</h2>\n<p><a href=\"https://loong13.debian.net/\">loong13</a> is a community-maintained port of Debian 13 stable to LoongArch, and Wang Miao is one of its maintainers. During the build and packaging process, normaliz's built-in test was found to get stuck in a loop that it could not exit, causing the packaging to time out. At the time we did not immediately find the root cause, so we had no choice but to skip this package. But since several other packages depend on normaliz, we could not keep skipping it forever, so in February we began to focus on investigating the problem. Previously, while building other packages, we had found hidden race conditions or memory-ordering issues in the code, and such problems are more likely to surface on LoongArch, which uses a weak memory model. So at first we guessed the cause might be a similar issue in this software. But once the investigation began, surprise, surprise, there was a surprise.</p>\n<h2 id=\"the-first-round-of-investigation\">The First Round of Investigation</h2>\n<p>The first round started from normaliz's source code. normaliz uses OpenMP to process data points in parallel. The problematic code snippet can be summarized as follows:</p>\n<div class=\"language-c++ highlight\"><pre><span></span><code><span id=\"__span-0-1\"><a id=\"__codelineno-0-1\" name=\"__codelineno-0-1\" href=\"#__codelineno-0-1\"></a><span class=\"n\">func</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">std</span><span class=\"o\">::</span><span class=\"n\">list</span><span class=\"o\">&lt;</span><span class=\"n\">std</span><span class=\"o\">::</span><span class=\"n\">vector</span><span class=\"o\">&lt;</span><span class=\"kt\">int</span><span class=\"o\">&gt;&gt;</span><span class=\"w\"> </span><span class=\"n\">LatticePoints</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"p\">{</span>\n</span><span id=\"__span-0-2\"><a id=\"__codelineno-0-2\" name=\"__codelineno-0-2\" href=\"#__codelineno-0-2\"></a>\n</span><span id=\"__span-0-3\"><a id=\"__codelineno-0-3\" name=\"__codelineno-0-3\" href=\"#__codelineno-0-3\"></a><span class=\"w\">  </span><span class=\"kt\">size_t</span><span class=\"w\"> </span><span class=\"n\">nr_to_match</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span><span class=\"n\">LatticePoints</span><span class=\"p\">.</span><span class=\"n\">size</span><span class=\"p\">();</span><span class=\"w\"> </span><span class=\"c1\">// input size</span>\n</span><span id=\"__span-0-4\"><a id=\"__codelineno-0-4\" name=\"__codelineno-0-4\" href=\"#__codelineno-0-4\"></a><span class=\"w\">  </span><span class=\"kt\">size_t</span><span class=\"w\"> </span><span class=\"n\">nr_points_matched</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span><span class=\"mi\">0</span><span class=\"p\">;</span><span class=\"w\"> </span><span class=\"c1\">// number of points already processed</span>\n</span><span id=\"__span-0-5\"><a id=\"__codelineno-0-5\" name=\"__codelineno-0-5\" href=\"#__codelineno-0-5\"></a>\n</span><span id=\"__span-0-6\"><a id=\"__codelineno-0-6\" name=\"__codelineno-0-6\" href=\"#__codelineno-0-6\"></a><span class=\"w\">  </span><span class=\"k\">while</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"nb\">true</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"p\">{</span>\n</span><span id=\"__span-0-7\"><a id=\"__codelineno-0-7\" name=\"__codelineno-0-7\" href=\"#__codelineno-0-7\"></a><span class=\"w\">    </span><span class=\"kt\">size_t</span><span class=\"w\"> </span><span class=\"n\">nr_points_done_in_this_round</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span><span class=\"mi\">0</span><span class=\"p\">;</span><span class=\"w\"> </span><span class=\"c1\">// number of points processed this round</span>\n</span><span id=\"__span-0-8\"><a id=\"__codelineno-0-8\" name=\"__codelineno-0-8\" href=\"#__codelineno-0-8\"></a>\n</span><span id=\"__span-0-9\"><a id=\"__codelineno-0-9\" name=\"__codelineno-0-9\" href=\"#__codelineno-0-9\"></a><span class=\"w\">    </span><span class=\"cp\">#pragma omp parallel</span>\n</span><span id=\"__span-0-10\"><a id=\"__codelineno-0-10\" name=\"__codelineno-0-10\" href=\"#__codelineno-0-10\"></a><span class=\"w\">    </span><span class=\"p\">{</span>\n</span><span id=\"__span-0-11\"><a id=\"__codelineno-0-11\" name=\"__codelineno-0-11\" href=\"#__codelineno-0-11\"></a><span class=\"w\">      </span><span class=\"k\">auto</span><span class=\"w\"> </span><span class=\"n\">P</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span><span class=\"n\">LatticePoints</span><span class=\"p\">.</span><span class=\"n\">begin</span><span class=\"p\">();</span><span class=\"w\"> </span><span class=\"c1\">// thread-private List pointer</span>\n</span><span id=\"__span-0-12\"><a id=\"__codelineno-0-12\" name=\"__codelineno-0-12\" href=\"#__codelineno-0-12\"></a><span class=\"w\">      </span><span class=\"kt\">size_t</span><span class=\"w\"> </span><span class=\"n\">ppos</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span><span class=\"mi\">0</span><span class=\"p\">;</span><span class=\"w\"> </span><span class=\"c1\">// thread-private List pointer position</span>\n</span><span id=\"__span-0-13\"><a id=\"__codelineno-0-13\" name=\"__codelineno-0-13\" href=\"#__codelineno-0-13\"></a><span class=\"w\">      </span><span class=\"cp\">#pragma omp for</span>\n</span><span id=\"__span-0-14\"><a id=\"__codelineno-0-14\" name=\"__codelineno-0-14\" href=\"#__codelineno-0-14\"></a><span class=\"w\">      </span><span class=\"k\">for</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">ppp</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span><span class=\"mf\">0.</span><span class=\"p\">..</span><span class=\"n\">nr_to_match</span><span class=\"p\">){</span>\n</span><span id=\"__span-0-15\"><a id=\"__codelineno-0-15\" name=\"__codelineno-0-15\" href=\"#__codelineno-0-15\"></a>\n</span><span id=\"__span-0-16\"><a id=\"__codelineno-0-16\" name=\"__codelineno-0-16\" href=\"#__codelineno-0-16\"></a><span class=\"w\">        </span><span class=\"k\">if</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">skip_remaining</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"p\">{</span><span class=\"w\"> </span><span class=\"c1\">// in certain cases skip_remaining is set, skipping unprocessed points</span>\n</span><span id=\"__span-0-17\"><a id=\"__codelineno-0-17\" name=\"__codelineno-0-17\" href=\"#__codelineno-0-17\"></a><span class=\"w\">          </span><span class=\"k\">continue</span><span class=\"p\">;</span>\n</span><span id=\"__span-0-18\"><a id=\"__codelineno-0-18\" name=\"__codelineno-0-18\" href=\"#__codelineno-0-18\"></a><span class=\"w\">        </span><span class=\"p\">}</span>\n</span><span id=\"__span-0-19\"><a id=\"__codelineno-0-19\" name=\"__codelineno-0-19\" href=\"#__codelineno-0-19\"></a>\n</span><span id=\"__span-0-20\"><a id=\"__codelineno-0-20\" name=\"__codelineno-0-20\" href=\"#__codelineno-0-20\"></a><span class=\"w\">        </span><span class=\"c1\">// Based on the difference between ppos and ppp, move P to the position</span>\n</span><span id=\"__span-0-21\"><a id=\"__codelineno-0-21\" name=\"__codelineno-0-21\" href=\"#__codelineno-0-21\"></a><span class=\"w\">        </span><span class=\"c1\">// pointed to by ppp and maintain ppos</span>\n</span><span id=\"__span-0-22\"><a id=\"__codelineno-0-22\" name=\"__codelineno-0-22\" href=\"#__codelineno-0-22\"></a>\n</span><span id=\"__span-0-23\"><a id=\"__codelineno-0-23\" name=\"__codelineno-0-23\" href=\"#__codelineno-0-23\"></a><span class=\"w\">        </span><span class=\"k\">if</span><span class=\"w\"> </span><span class=\"p\">((</span><span class=\"o\">*</span><span class=\"n\">P</span><span class=\"p\">)[</span><span class=\"mi\">0</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">==</span><span class=\"w\"> </span><span class=\"mi\">0</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"p\">{</span><span class=\"w\"> </span><span class=\"c1\">// means it has been processed</span>\n</span><span id=\"__span-0-24\"><a id=\"__codelineno-0-24\" name=\"__codelineno-0-24\" href=\"#__codelineno-0-24\"></a><span class=\"w\">          </span><span class=\"k\">continue</span><span class=\"p\">;</span>\n</span><span id=\"__span-0-25\"><a id=\"__codelineno-0-25\" name=\"__codelineno-0-25\" href=\"#__codelineno-0-25\"></a><span class=\"w\">        </span><span class=\"p\">}</span>\n</span><span id=\"__span-0-26\"><a id=\"__codelineno-0-26\" name=\"__codelineno-0-26\" href=\"#__codelineno-0-26\"></a>\n</span><span id=\"__span-0-27\"><a id=\"__codelineno-0-27\" name=\"__codelineno-0-27\" href=\"#__codelineno-0-27\"></a><span class=\"w\">        </span><span class=\"cp\">#pragma omp atomic</span>\n</span><span id=\"__span-0-28\"><a id=\"__codelineno-0-28\" name=\"__codelineno-0-28\" href=\"#__codelineno-0-28\"></a><span class=\"w\">        </span><span class=\"n\">nr_points_matched</span><span class=\"o\">++</span><span class=\"p\">;</span>\n</span><span id=\"__span-0-29\"><a id=\"__codelineno-0-29\" name=\"__codelineno-0-29\" href=\"#__codelineno-0-29\"></a><span class=\"w\">        </span><span class=\"cp\">#pragma omp atomic</span>\n</span><span id=\"__span-0-30\"><a id=\"__codelineno-0-30\" name=\"__codelineno-0-30\" href=\"#__codelineno-0-30\"></a><span class=\"w\">        </span><span class=\"n\">nr_points_done_in_this_round</span><span class=\"o\">++</span><span class=\"p\">;</span>\n</span><span id=\"__span-0-31\"><a id=\"__codelineno-0-31\" name=\"__codelineno-0-31\" href=\"#__codelineno-0-31\"></a>\n</span><span id=\"__span-0-32\"><a id=\"__codelineno-0-32\" name=\"__codelineno-0-32\" href=\"#__codelineno-0-32\"></a><span class=\"w\">        </span><span class=\"c1\">// process the object pointed to by P</span>\n</span><span id=\"__span-0-33\"><a id=\"__codelineno-0-33\" name=\"__codelineno-0-33\" href=\"#__codelineno-0-33\"></a><span class=\"w\">        </span><span class=\"p\">(</span><span class=\"o\">*</span><span class=\"n\">P</span><span class=\"p\">)[</span><span class=\"mi\">0</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span><span class=\"mi\">0</span><span class=\"p\">;</span>\n</span><span id=\"__span-0-34\"><a id=\"__codelineno-0-34\" name=\"__codelineno-0-34\" href=\"#__codelineno-0-34\"></a><span class=\"w\">      </span><span class=\"p\">}</span>\n</span><span id=\"__span-0-35\"><a id=\"__codelineno-0-35\" name=\"__codelineno-0-35\" href=\"#__codelineno-0-35\"></a><span class=\"w\">    </span><span class=\"p\">}</span>\n</span><span id=\"__span-0-36\"><a id=\"__codelineno-0-36\" name=\"__codelineno-0-36\" href=\"#__codelineno-0-36\"></a>\n</span><span id=\"__span-0-37\"><a id=\"__codelineno-0-37\" name=\"__codelineno-0-37\" href=\"#__codelineno-0-37\"></a><span class=\"w\">    </span><span class=\"c1\">// this break never gets executed</span>\n</span><span id=\"__span-0-38\"><a id=\"__codelineno-0-38\" name=\"__codelineno-0-38\" href=\"#__codelineno-0-38\"></a><span class=\"w\">    </span><span class=\"k\">if</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">nr_points_matched</span><span class=\"w\"> </span><span class=\"o\">==</span><span class=\"w\"> </span><span class=\"n\">nr_to_match</span><span class=\"p\">)</span>\n</span><span id=\"__span-0-39\"><a id=\"__codelineno-0-39\" name=\"__codelineno-0-39\" href=\"#__codelineno-0-39\"></a><span class=\"w\">      </span><span class=\"k\">break</span><span class=\"p\">;</span>\n</span><span id=\"__span-0-40\"><a id=\"__codelineno-0-40\" name=\"__codelineno-0-40\" href=\"#__codelineno-0-40\"></a><span class=\"w\">  </span><span class=\"p\">}</span>\n</span><span id=\"__span-0-41\"><a id=\"__codelineno-0-41\" name=\"__codelineno-0-41\" href=\"#__codelineno-0-41\"></a>\n</span><span id=\"__span-0-42\"><a id=\"__codelineno-0-42\" name=\"__codelineno-0-42\" href=\"#__codelineno-0-42\"></a><span class=\"p\">}</span>\n</span></code></pre></div>\n<p>The gist of this code is: for a given <code>LatticePoints</code> list, the program processes each point in parallel. While processing each data point, some points may be temporarily skipped, requiring repeated passes until all data points have been processed. In this code, <code>nr_to_match</code> is the total number of data points, <code>nr_points_matched</code> is the number of points already processed, and <code>nr_points_done_in_this_round</code> is the number of points processed this round. The loop's termination condition is <code>nr_points_matched</code> equaling <code>nr_to_match</code>, i.e. all data points processed. The direct cause of the infinite loop is that <code>nr_points_matched</code> never reaches <code>nr_to_match</code>, so the loop cannot terminate. Using gdb, one can find that when this happens, every point in the entire <code>LatticePoints</code> list has been marked as processed, so <code>nr_points_matched</code> stops increasing, yet the loop's exit condition is never satisfied, so it just keeps looping. The question then becomes: why does the value of the counter <code>nr_points_matched</code> not match the actual number of processed data points. According to the code, the per-round increment of <code>nr_points_matched</code> should equal that of <code>nr_points_done_in_this_round</code>, because they are always atomically incremented together. But the actual output was not so: the two counters' values differ slightly, and the gap is unstable, with the result varying from run to run.</p>\n<p>The first thing ruled out was a memory-ordering issue: this code does not rely on atomic variables to synchronize other variables; in other words, it operates on and reads only the atomic variables themselves the whole time, so from the code's perspective it is logically correct. The next suspicion was whether the OpenMP implementation was at fault: whether the atomic operations annotated with <code>#pragma omp atomic</code> really guarantee atomicity. From the disassembly, one can see the compiler generated the LoongArch64 <code>amadd.d</code> instruction for these atomic operations, as expected. To investigate this, we set up two additional <code>std::atomic</code> counters as controls, used alongside the original two, to see whether the results agreed. It turned out that the four counters' values (computed from the per-round increments) should have agreed, but in fact they showed random discrepancies. This hinted that the atomic add instruction loses updates under certain conditions.</p>\n<p>However, testing the atomicity of the atomic add instruction with a simple atomic add program could not reproduce the lost update. To find a minimal reproducer, we simplified the aforementioned normaliz processing logic into a similar test program, which also could not reproduce the problem. So we had to keep commenting out computation steps in normaliz's actually-running code, trying to find the minimal condition that triggers the lost atomic add. One bizarre phenomenon was that even after commenting out most of the computation steps, the problem persisted. Because the program was too complex, in the end we still could not find a minimal code snippet that reliably reproduced the lost atomic add.</p>\n<h2 id=\"the-second-round-of-investigation\">The Second Round of Investigation</h2>\n<p>Six months later, the problem remained unsolved. With the disclosure of the <a href=\"../../../08/18/loongleak-loongbleed/\">LoongLeak/LoongBleed vulnerabilities</a>, the lost atomic add in normaliz came back into our view. This time, we tried to use AI to assist the investigation. The method was: first point out to the AI that the above normaliz code has an infinite-loop problem, ask the AI to confirm and reproduce it, and then find the possible cause. In the first round of conversation, the AI noticed the problematic loop but did not conclude that the atomic add instruction was at fault. After that, we hinted to the AI that the problem exists only on LoongArch and not on other architectures, but the AI still could not give a definite conclusion. Finally, we directly told the AI the fact that we had already localized the problem to the atomic add, and asked it to reproduce it and provide a minimal reproducer. In that round of conversation, the AI eventually turned its attention to a <code>memcpy</code> call in the processing function, which was exactly the part overlooked in the first round: <code>memcpy</code>'s implementation lives in glibc, and glibc chooses the optimal implementation based on currently available hardware features; if the hardware supports a vector instruction set (LSX/LASX on LoongArch), glibc's <code>memcpy</code> will use the corresponding vector instructions to accelerate memory copying. And it was precisely these vectorized memory copies that triggered the lost atomic add on LoongArch64. Two days later, the AI produced a minimal program that reliably reproduces the problem.</p>\n<h2 id=\"expanding-the-scope\">Expanding the Scope</h2>\n<p>After discovering that the atomic add instruction can lose updates, we had new questions: first, is only atomic add affected, or do other atomic instructions have the same problem; second, do other memory operations also trigger similar problems.</p>\n<p>For the first question, we first investigated the CAS instruction, because it can be used to implement atomic addition, making it easy to tell whether something goes wrong. It turned out that CAS also has the problem under the same conditions. For other atomic instructions, such as atomic swap, atomic max, atomic min, atomic bitwise AND, atomic bitwise OR, and so on, since even a lost update is not easy to detect from the result, we did not verify them at first. For example, if a lost update happens during an atomic max, then as long as the operation that updated the maximum was not lost, the result is correct.</p>\n<p>After much thought, we finally found a verification scheme: to check whether such instructions lose updates, we recorded the result of every operation and verified afterward. Take atomic max as an example: if you atomically take the max over the numbers 1 to n in parallel, the final result should be n. Each atomic max modifies the memory and also returns the old maximum. For an operation with input k, if the returned old value is less than k, then this operation updated the maximum. Atomicity guarantees that the return values of all operations that updated the maximum will not repeat. If a repeat occurs, then a lost update of the atomic instruction occurred. Verification showed that these atomic instructions all lose updates under the same conditions.</p>\n<p>For the second question, we found in testing that only LASX vectorized memory reads (<code>xvld</code>) trigger the lost atomic instruction; normal scalar reads and LSX vectorized memory reads (<code>vld</code>) do not trigger the problem. Later, <a href=\"https://github.com/CSharperMantle\">Rong \"Mantle\" Bao</a> independently discovered that when the memory address of the atomic variable and the read memory address have a particular positional relationship, normal scalar reads can also trigger the lost atomic instruction, meaning the problem can occur even without LASX, just with lower probability. These complex triggering conditions explain why this problem went undiscovered for so long.</p>\n<h2 id=\"specific-conclusions\">Specific Conclusions</h2>\n<p>Before presenting the specific conclusions, let us first introduce the background: Loongson's 3C6000/S and 3A6000 use the LA664 core, whose instruction set is LoongArch64 with SIMD extensions; of these, the 128-bit SIMD extension is called LSX and the 256-bit one is called LASX. The earlier LA464 core (such as the 3A5000) does not have this problem. LASX includes the memory-read instruction <code>xvld</code>, which can read 32 bytes at a time into a vector register. Loongson's atomic instructions can be summarized as <code>am&lt;OP&gt;[_db].&lt;width&gt;</code>, where <code>&lt;OP&gt;</code> is the specific atomic operation, such as <code>amadd</code>, <code>amcas</code>, <code>amswap</code>, <code>ammax</code>, <code>amxor</code>, <code>amand</code>, <code>amor</code>, etc.; <code>[_db]</code> indicates whether it carries a data barrier (db); and <code>&lt;width&gt;</code> is the data width of the operation, e.g. <code>.d</code> for 64-bit and <code>.w</code> for 32-bit.</p>\n<p>Summarizing the experimental results, reproducing a lost atomic operation requires all three of the following conditions at once:</p>\n<ul>\n<li>The threads run on different physical cores (i.e. not two SMT logical cores on the same physical core);</li>\n<li>These threads perform atomic operations without a data barrier on the same address;</li>\n<li>At least one of the threads interleaves memory reads between atomic operations.</li>\n</ul>\n<p>Here, the memory-read operation can be the LASX vectorized memory read <code>xvld</code>; when the read memory address and the atomic operation's memory address have a particular positional relationship, the memory-read operation can also be an ordinary scalar read.</p>\n<h2 id=\"reproduction-and-measurement\">Reproduction and Measurement</h2>\n<p>The minimal reproducer came from the AI's simplification of the normaliz code. Each normaliz data point is 2208 bytes, i.e. 276 <code>uint64_t</code>s. Two threads traverse these points in shards; for each point they first do a vectorized memory copy (<code>memcpy</code>), then do one relaxed atomic add on each of three shared counters (corresponding to the amadd instruction without a data barrier). After each round, they check whether the three counters are equal; if not, a lost update occurred.</p>\n<p>On a 3C6000/S, using two different physical cores (e.g. CPU0 and CPU2), 2208 bytes per point, 200 rounds per trial, and 30 trials in total, we obtained the following results:</p>\n<table>\n<thead>\n<tr>\n<th>Atomic Op</th>\n<th style=\"text-align: right;\">Both do LASX copy</th>\n<th style=\"text-align: right;\">Both do LASX read</th>\n<th style=\"text-align: right;\">One side LASX copy</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>amadd.d</code></td>\n<td style=\"text-align: right;\">67%</td>\n<td style=\"text-align: right;\">100%</td>\n<td style=\"text-align: right;\">53%</td>\n</tr>\n<tr>\n<td><code>amadd.w</code></td>\n<td style=\"text-align: right;\">73%</td>\n<td style=\"text-align: right;\">100%</td>\n<td style=\"text-align: right;\">67%</td>\n</tr>\n<tr>\n<td><code>amcas.d</code></td>\n<td style=\"text-align: right;\">77%</td>\n<td style=\"text-align: right;\">97%</td>\n<td style=\"text-align: right;\">17%</td>\n</tr>\n<tr>\n<td><code>amcas_db.d</code></td>\n<td style=\"text-align: right;\">0%</td>\n<td style=\"text-align: right;\">0%</td>\n<td style=\"text-align: right;\">0%</td>\n</tr>\n<tr>\n<td><code>ammax.d</code></td>\n<td style=\"text-align: right;\">43%</td>\n<td style=\"text-align: right;\">100%</td>\n<td style=\"text-align: right;\">50%</td>\n</tr>\n<tr>\n<td><code>amswap.d</code></td>\n<td style=\"text-align: right;\">53%</td>\n<td style=\"text-align: right;\">100%</td>\n<td style=\"text-align: right;\">53%</td>\n</tr>\n</tbody>\n</table>\n<p>The percentages in the table are \"the proportion of trials that failed out of 30 trials\". One can see that \"both do LASX read\" most easily triggers the problem, with a probability of almost 100%; <code>amcas_db.d</code> with db is always 0% under the same conditions.</p>\n<h2 id=\"an-aside-why-aosc-could-no-longer-reproduce-it-later\">An Aside: Why AOSC Could No Longer Reproduce It Later</h2>\n<p>During the process of reproducing this problem, there was a small aside, and it is also the most interesting part of the whole story. When the problem was first discovered in February, both AOSC OS and Debian could reproduce the normaliz infinite loop. But when we re-investigated in August, AOSC could not reproduce it no matter what, while Debian still could. At the time we did not know why this inconsistency occurred, and just kept experimenting on Debian.</p>\n<p>Later, as the AI localized the problem to <code>memcpy</code>, we understood the reason. The Core 13 release that AOSC shipped after February had mistakenly disabled the <code>--enable-multi-arch</code> option in glibc, so the system <code>memcpy</code> no longer took the LASX acceleration path; whereas Debian's glibc enables vector acceleration normally, so its <code>memcpy</code> uses LASX. In February, both AOSC and Debian used the LASX acceleration path; by August, AOSC's <code>memcpy</code> no longer used LASX acceleration, so naturally it could not be triggered. On Debian, disabling LASX acceleration with <code>GLIBC_TUNABLES=glibc.cpu.hwcaps=-LASX</code> also stopped the problem from triggering.</p>\n<p>So once AOSC releases Core 14 and re-enables the <code>--enable-multi-arch</code> option, the problem will reappear. Considering how commonly <code>memcpy</code> is used, the number of affected programs may be larger than we imagine, only because the trigger probability is low that it is hard to notice.</p>\n<h2 id=\"impact-analysis\">Impact Analysis</h2>\n<p>Among the problematic atomic instructions, <code>ammax</code>, <code>ammin</code>, and the like are hard for compilers to generate because the C standard currently has no corresponding atomic operation interface; and <code>amcas</code> is an instruction newly added in LoongArch64 v1.1, so it is also not generated by compilers by default. The one that may have the largest impact is <code>amadd</code>, the atomic add instruction. This instruction is typically used for reference counting: if an increment of the reference count is lost, the count becomes smaller than the actual number of references, which may cause an object to be freed prematurely, leading to memory-safety problems such as use-after-free or double free. And the other triggering condition, vectorized memory reads, is easily triggered by functions like <code>memcpy</code>. We found that in the Rust standard library, the reference count of <code>std::sync::Arc</code> and the cloning of <code>std::sync::mpsc</code>'s <code>Sender</code> also use the <code>amadd</code> instruction without a data barrier. We constructed a safe Rust program; using either <code>Arc</code> or <code>mpsc</code> could make the program crash, manifesting as SIGABRT or glibc reporting heap corruption, which means a use-after-free occurred.</p>\n<p>However, this problem is hard to use for a security attack. To trigger it, two threads must concurrently perform relaxed atomic operations on the same counter of the same object, and at least one of them must be doing a vectorized memory read. This triggering condition means the potential attacker and victim must be in the same process, and cannot be separated by process isolation, so it is hard to exploit unilaterally.</p>\n<h2 id=\"workarounds\">Workarounds</h2>\n<p>In general, since in high-level language code developers have no control over the atomic instructions the compiler produces, application developers have no direct workaround. Software-level workarounds are mainly implemented through the compiler, i.e. the compiler no longer generates atomic instructions without a data barrier (<code>am&lt;OP&gt;.*</code>) but instead generates atomic instructions with a data barrier (<code>am&lt;OP&gt;_db.*</code>), or implements atomic operations using LL/SC loops. But for already-existing binaries, applying these workarounds requires a full recompile. Therefore, the cost of avoiding the problem at the software level is high.</p>\n<h2 id=\"the-fix\">The Fix</h2>\n<p>After we reported it to Loongson, the fix came quickly: we emailed the problem to Loongson on August 26, 2026, and just two weeks later, on September 9, 2026, we received test firmware; both the 3A6000 and 3C6000/S returned to normal in our tests. Loongson told us this firmware is expected to be released before National Day (October 1).</p>\n<p>The fix is to set bit 13 of MCSR24 to 1. MCSR24 is an internal CSR whose function is not described in the manual. After setting this bit, the lost update no longer occurs. Testing showed the performance loss is very small: single-core performance is unaffected, and multi-core performance drops only slightly.</p>\n<p>If affected users cannot update the firmware for the time being, they can also choose to write this bit directly in the Linux kernel, which is equivalent to applying the firmware fix and avoids waiting for a motherboard firmware update.</p>\n<h2 id=\"conclusion\">Conclusion</h2>\n<p>Looking back, this story began with a purely software problem: an infinite loop during packaging, a counter that occasionally miscounts. In the end it turned out to be an atomic add instruction in the CPU that is not atomic. From discovering the problem to finding the cause spanned half a year, yet the truly effective progress took only two days, with both AI and humans playing indispensable roles. The rest of the time went into confirming the problem, finding the triggering conditions, broadening the testing scope, and waiting for the firmware fix.</p>\n<p>In fact, similar errata are very common in CPUs from all vendors. Interested readers can browse ARM's Software Developer Errata Notice for its cores, many of which involve memory-access or atomic instructions, with a few severe ones even causing the CPU to deadlock; but those that genuinely affect the user experience are actually very few. For such problems, rather than letting one suddenly surface someday in some complex system as an unstable error report, it is better to localize the specific cause and fix it as early as possible.</p>\n<h2 id=\"acknowledgements\">Acknowledgements</h2>\n<p>This work was initiated and led by Wang Miao; I was responsible for reproduction and writing up the report. After we informed them that <code>amcas</code> also had the problem, <a href=\"https://github.com/CSharperMantle\">Rong \"Mantle\" Bao</a> discovered a similar CPU problem, which was fixed together. Thanks to Loongson's Chip R&amp;D Department and Developer Community Operations Department, among others, for their efficient and professional work throughout the reporting and fixing process!</p>","date_modified":"2026-09-24T00:00:00+00:00","date_published":"2026-09-24T00:00:00+00:00","id":"https://jia.je/hardware/2026/09/24/loongson-cpu-erratum-en/","image":null,"tags":["cpu","erratum","hardware","loongarch","loongson"],"title":"One CPU Atomic Instruction, One Packaging Infinite Loop: The Story of the Lost Update on LA664","url":"https://jia.je/hardware/2026/09/24/loongson-cpu-erratum-en/"},{"authors":[],"content_html":"<h1 id=\"一颗-cpu-的原子指令一个打包死循环la664-丢失更新事件始末\">一颗 CPU 的原子指令，一个打包死循环：LA664 丢失更新事件始末</h1>\n<p>本文同步发布到本人的<a href=\"https://zhuanlan.zhihu.com/p/2086506162388846262\">知乎</a>。</p>\n<p><a href=\"../loongson-cpu-erratum-en/\">English version</a></p>\n<h2 id=\"太长不看版本\">太长不看版本</h2>\n<p>2026 年 2 月，<a href=\"https://github.com/shankerwangmiao\">王邈</a>在龙架构服务器上给 Debian 打包 normaliz 时遇到一件怪事：这个数学软件的自带测试总是超时，现象是卡在死循环里出不来。顺着代码调查，问题指向一个很常规的操作：OpenMP 的 <code>#pragma omp atomic</code> 对共享变量进行累加。循环的退出条件要求累加后的值等于某个数，而累加的结果总是少于这个数，就导致了死循环。由于程序太大、代码又很复杂，始终没能把问题缩减成一个人类能看懂的最小例子，这件事就被搁置了。</p>\n<p>半年后的 8 月，王邈再次找到我，想把它重新捡起来。这回我们换了个做法：不再由人来定位问题，而是让 AI 去找最小复现，人在这个过程中负责指挥 AI 调查的方向。大概两天后，我们拿到一个稳定的复现程序，才发现事情的根源是：CPU 的原子加法指令，居然偶尔会不原子。这意味着我们找到了 CPU 的一个新 erratum，而龙芯得知这件事后，仅仅过了两周，就找到了几乎没有性能损失的修复方法，并给我们提供了测试固件。我们确认了测试固件可以解决问题，并且龙芯告诉我们，该测试固件预计在国庆（10 月 1 日）之前发布，届时读者将可以升级固件以修复该问题。</p>\n<!-- more -->\n\n<p>下面，让我们把整个事件的来龙去脉娓娓道来。</p>\n<h2 id=\"缘起\">缘起</h2>\n<p><a href=\"https://loong13.debian.net/\">loong13</a> 是社区维护的一个 Debian 13 稳定版在龙架构上的移植，王邈是维护者之一。在编译打包过程中，发现 normaliz 的自带测试会卡在循环里无法退出，导致打包超时。当时并没有立即找到问题的根源，只好先跳过这个软件包。但由于有一些其它软件包依赖 normaliz，不能一直跳过，2 月份的时候，我们开始集中精力排查这个问题。此前在构建其它软件包的过程中，我们发现过代码中暗藏的竞态条件或内存序问题，这类问题更容易在采用弱内存序的龙架构上暴露出来。因此，一开始我们推测，原因可能是该软件也存在类似的问题。但是在排查开始后，不出意外就出了意外。</p>\n<h2 id=\"第一轮排查\">第一轮排查</h2>\n<p>第一轮排查从 normaliz 的源码开始。normaliz 使用 OpenMP 并行处理数据点，出问题的代码片段概括起来如下所示：</p>\n<div class=\"language-c++ highlight\"><pre><span></span><code><span id=\"__span-0-1\"><a id=\"__codelineno-0-1\" name=\"__codelineno-0-1\" href=\"#__codelineno-0-1\"></a><span class=\"n\">func</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">std</span><span class=\"o\">::</span><span class=\"n\">list</span><span class=\"o\">&lt;</span><span class=\"n\">std</span><span class=\"o\">::</span><span class=\"n\">vector</span><span class=\"o\">&lt;</span><span class=\"kt\">int</span><span class=\"o\">&gt;&gt;</span><span class=\"w\"> </span><span class=\"n\">LatticePoints</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"p\">{</span>\n</span><span id=\"__span-0-2\"><a id=\"__codelineno-0-2\" name=\"__codelineno-0-2\" href=\"#__codelineno-0-2\"></a>\n</span><span id=\"__span-0-3\"><a id=\"__codelineno-0-3\" name=\"__codelineno-0-3\" href=\"#__codelineno-0-3\"></a><span class=\"w\">  </span><span class=\"kt\">size_t</span><span class=\"w\"> </span><span class=\"n\">nr_to_match</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span><span class=\"n\">LatticePoints</span><span class=\"p\">.</span><span class=\"n\">size</span><span class=\"p\">();</span><span class=\"w\"> </span><span class=\"c1\">// 输入大小</span>\n</span><span id=\"__span-0-4\"><a id=\"__codelineno-0-4\" name=\"__codelineno-0-4\" href=\"#__codelineno-0-4\"></a><span class=\"w\">  </span><span class=\"kt\">size_t</span><span class=\"w\"> </span><span class=\"n\">nr_points_matched</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span><span class=\"mi\">0</span><span class=\"p\">;</span><span class=\"w\"> </span><span class=\"c1\">// 维护已经处理了的点的数目</span>\n</span><span id=\"__span-0-5\"><a id=\"__codelineno-0-5\" name=\"__codelineno-0-5\" href=\"#__codelineno-0-5\"></a>\n</span><span id=\"__span-0-6\"><a id=\"__codelineno-0-6\" name=\"__codelineno-0-6\" href=\"#__codelineno-0-6\"></a><span class=\"w\">  </span><span class=\"k\">while</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"nb\">true</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"p\">{</span>\n</span><span id=\"__span-0-7\"><a id=\"__codelineno-0-7\" name=\"__codelineno-0-7\" href=\"#__codelineno-0-7\"></a><span class=\"w\">    </span><span class=\"kt\">size_t</span><span class=\"w\"> </span><span class=\"n\">nr_points_done_in_this_round</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span><span class=\"mi\">0</span><span class=\"p\">;</span><span class=\"w\"> </span><span class=\"c1\">// 维护本轮处理了的点的数目</span>\n</span><span id=\"__span-0-8\"><a id=\"__codelineno-0-8\" name=\"__codelineno-0-8\" href=\"#__codelineno-0-8\"></a>\n</span><span id=\"__span-0-9\"><a id=\"__codelineno-0-9\" name=\"__codelineno-0-9\" href=\"#__codelineno-0-9\"></a><span class=\"w\">    </span><span class=\"cp\">#pragma omp parallel</span>\n</span><span id=\"__span-0-10\"><a id=\"__codelineno-0-10\" name=\"__codelineno-0-10\" href=\"#__codelineno-0-10\"></a><span class=\"w\">    </span><span class=\"p\">{</span>\n</span><span id=\"__span-0-11\"><a id=\"__codelineno-0-11\" name=\"__codelineno-0-11\" href=\"#__codelineno-0-11\"></a><span class=\"w\">      </span><span class=\"k\">auto</span><span class=\"w\"> </span><span class=\"n\">P</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span><span class=\"n\">LatticePoints</span><span class=\"p\">.</span><span class=\"n\">begin</span><span class=\"p\">();</span><span class=\"w\"> </span><span class=\"c1\">// 线程私有的 List 指针</span>\n</span><span id=\"__span-0-12\"><a id=\"__codelineno-0-12\" name=\"__codelineno-0-12\" href=\"#__codelineno-0-12\"></a><span class=\"w\">      </span><span class=\"kt\">size_t</span><span class=\"w\"> </span><span class=\"n\">ppos</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span><span class=\"mi\">0</span><span class=\"p\">;</span><span class=\"w\"> </span><span class=\"c1\">// 线程私有的 List 指针位置</span>\n</span><span id=\"__span-0-13\"><a id=\"__codelineno-0-13\" name=\"__codelineno-0-13\" href=\"#__codelineno-0-13\"></a><span class=\"w\">      </span><span class=\"cp\">#pragma omp for</span>\n</span><span id=\"__span-0-14\"><a id=\"__codelineno-0-14\" name=\"__codelineno-0-14\" href=\"#__codelineno-0-14\"></a><span class=\"w\">      </span><span class=\"k\">for</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">ppp</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span><span class=\"mf\">0.</span><span class=\"p\">..</span><span class=\"n\">nr_to_match</span><span class=\"p\">){</span>\n</span><span id=\"__span-0-15\"><a id=\"__codelineno-0-15\" name=\"__codelineno-0-15\" href=\"#__codelineno-0-15\"></a>\n</span><span id=\"__span-0-16\"><a id=\"__codelineno-0-16\" name=\"__codelineno-0-16\" href=\"#__codelineno-0-16\"></a><span class=\"w\">        </span><span class=\"k\">if</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">skip_remaining</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"p\">{</span><span class=\"w\"> </span><span class=\"c1\">// 特定情况下会设置 skip_remaining，从而跳过未处理的点</span>\n</span><span id=\"__span-0-17\"><a id=\"__codelineno-0-17\" name=\"__codelineno-0-17\" href=\"#__codelineno-0-17\"></a><span class=\"w\">          </span><span class=\"k\">continue</span><span class=\"p\">;</span>\n</span><span id=\"__span-0-18\"><a id=\"__codelineno-0-18\" name=\"__codelineno-0-18\" href=\"#__codelineno-0-18\"></a><span class=\"w\">        </span><span class=\"p\">}</span>\n</span><span id=\"__span-0-19\"><a id=\"__codelineno-0-19\" name=\"__codelineno-0-19\" href=\"#__codelineno-0-19\"></a>\n</span><span id=\"__span-0-20\"><a id=\"__codelineno-0-20\" name=\"__codelineno-0-20\" href=\"#__codelineno-0-20\"></a><span class=\"w\">        </span><span class=\"c1\">// 根据 ppos 和 ppp 的差值，将 P 挪动至 ppp 所指位置</span>\n</span><span id=\"__span-0-21\"><a id=\"__codelineno-0-21\" name=\"__codelineno-0-21\" href=\"#__codelineno-0-21\"></a><span class=\"w\">        </span><span class=\"c1\">// 并维护 ppos</span>\n</span><span id=\"__span-0-22\"><a id=\"__codelineno-0-22\" name=\"__codelineno-0-22\" href=\"#__codelineno-0-22\"></a>\n</span><span id=\"__span-0-23\"><a id=\"__codelineno-0-23\" name=\"__codelineno-0-23\" href=\"#__codelineno-0-23\"></a><span class=\"w\">        </span><span class=\"k\">if</span><span class=\"w\"> </span><span class=\"p\">((</span><span class=\"o\">*</span><span class=\"n\">P</span><span class=\"p\">)[</span><span class=\"mi\">0</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">==</span><span class=\"w\"> </span><span class=\"mi\">0</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"p\">{</span><span class=\"w\"> </span><span class=\"c1\">// 表示处理过了</span>\n</span><span id=\"__span-0-24\"><a id=\"__codelineno-0-24\" name=\"__codelineno-0-24\" href=\"#__codelineno-0-24\"></a><span class=\"w\">          </span><span class=\"k\">continue</span><span class=\"p\">;</span>\n</span><span id=\"__span-0-25\"><a id=\"__codelineno-0-25\" name=\"__codelineno-0-25\" href=\"#__codelineno-0-25\"></a><span class=\"w\">        </span><span class=\"p\">}</span>\n</span><span id=\"__span-0-26\"><a id=\"__codelineno-0-26\" name=\"__codelineno-0-26\" href=\"#__codelineno-0-26\"></a>\n</span><span id=\"__span-0-27\"><a id=\"__codelineno-0-27\" name=\"__codelineno-0-27\" href=\"#__codelineno-0-27\"></a><span class=\"w\">        </span><span class=\"cp\">#pragma omp atomic</span>\n</span><span id=\"__span-0-28\"><a id=\"__codelineno-0-28\" name=\"__codelineno-0-28\" href=\"#__codelineno-0-28\"></a><span class=\"w\">        </span><span class=\"n\">nr_points_matched</span><span class=\"o\">++</span><span class=\"p\">;</span>\n</span><span id=\"__span-0-29\"><a id=\"__codelineno-0-29\" name=\"__codelineno-0-29\" href=\"#__codelineno-0-29\"></a><span class=\"w\">        </span><span class=\"cp\">#pragma omp atomic</span>\n</span><span id=\"__span-0-30\"><a id=\"__codelineno-0-30\" name=\"__codelineno-0-30\" href=\"#__codelineno-0-30\"></a><span class=\"w\">        </span><span class=\"n\">nr_points_done_in_this_round</span><span class=\"o\">++</span><span class=\"p\">;</span>\n</span><span id=\"__span-0-31\"><a id=\"__codelineno-0-31\" name=\"__codelineno-0-31\" href=\"#__codelineno-0-31\"></a>\n</span><span id=\"__span-0-32\"><a id=\"__codelineno-0-32\" name=\"__codelineno-0-32\" href=\"#__codelineno-0-32\"></a><span class=\"w\">        </span><span class=\"c1\">// 处理 P 所指对象</span>\n</span><span id=\"__span-0-33\"><a id=\"__codelineno-0-33\" name=\"__codelineno-0-33\" href=\"#__codelineno-0-33\"></a><span class=\"w\">        </span><span class=\"p\">(</span><span class=\"o\">*</span><span class=\"n\">P</span><span class=\"p\">)[</span><span class=\"mi\">0</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span><span class=\"mi\">0</span><span class=\"p\">;</span>\n</span><span id=\"__span-0-34\"><a id=\"__codelineno-0-34\" name=\"__codelineno-0-34\" href=\"#__codelineno-0-34\"></a><span class=\"w\">      </span><span class=\"p\">}</span>\n</span><span id=\"__span-0-35\"><a id=\"__codelineno-0-35\" name=\"__codelineno-0-35\" href=\"#__codelineno-0-35\"></a><span class=\"w\">    </span><span class=\"p\">}</span>\n</span><span id=\"__span-0-36\"><a id=\"__codelineno-0-36\" name=\"__codelineno-0-36\" href=\"#__codelineno-0-36\"></a>\n</span><span id=\"__span-0-37\"><a id=\"__codelineno-0-37\" name=\"__codelineno-0-37\" href=\"#__codelineno-0-37\"></a><span class=\"w\">    </span><span class=\"c1\">// 一直没能执行这个 break</span>\n</span><span id=\"__span-0-38\"><a id=\"__codelineno-0-38\" name=\"__codelineno-0-38\" href=\"#__codelineno-0-38\"></a><span class=\"w\">    </span><span class=\"k\">if</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">nr_points_matched</span><span class=\"w\"> </span><span class=\"o\">==</span><span class=\"w\"> </span><span class=\"n\">nr_to_match</span><span class=\"p\">)</span>\n</span><span id=\"__span-0-39\"><a id=\"__codelineno-0-39\" name=\"__codelineno-0-39\" href=\"#__codelineno-0-39\"></a><span class=\"w\">      </span><span class=\"k\">break</span><span class=\"p\">;</span>\n</span><span id=\"__span-0-40\"><a id=\"__codelineno-0-40\" name=\"__codelineno-0-40\" href=\"#__codelineno-0-40\"></a><span class=\"w\">  </span><span class=\"p\">}</span>\n</span><span id=\"__span-0-41\"><a id=\"__codelineno-0-41\" name=\"__codelineno-0-41\" href=\"#__codelineno-0-41\"></a>\n</span><span id=\"__span-0-42\"><a id=\"__codelineno-0-42\" name=\"__codelineno-0-42\" href=\"#__codelineno-0-42\"></a><span class=\"p\">}</span>\n</span></code></pre></div>\n<p>这段代码的大意是：对于给定的 <code>LatticePoints</code> 列表，程序会并行地处理每一个点。在处理每一个数据点时，有些数据点有可能会被暂时跳过，需要反复遍历，直到所有的数据点都被处理完毕为止。具体到这段代码，其中 <code>nr_to_match</code> 表示总的数据点数，<code>nr_points_matched</code> 表示已经处理完的数据点数，<code>nr_points_done_in_this_round</code> 表示本轮处理的数据点数。循环终止的条件是 <code>nr_points_matched</code> 等于 <code>nr_to_match</code>，即所有的数据点都被处理。而导致死循环的直接原因是，<code>nr_points_matched</code> 永远达不到 <code>nr_to_match</code>，从而导致循环无法终止。使用 gdb 调试可以发现，在出现这种情况时，整个 <code>LatticePoints</code> 列表中的所有点都被标记为处理过了，因此 <code>nr_points_matched</code> 不再增加，但循环的退出条件始终不满足，于是就一直循环下去。那么问题就变成了：为什么计数器 <code>nr_points_matched</code> 的值和实际处理的数据点数不一致。根据代码，<code>nr_points_matched</code> 每一轮的增量会与 <code>nr_points_done_in_this_round</code> 相等，因为它们总是一起原子加一。但实际输出却并非如此：两个计数器的值会有些许差别，而且差距不稳定，每次运行得到的结果可能都不相同。</p>\n<p>首先排除的是内存序问题：这段代码并不依赖原子变量来同步其它变量，也就是说，它自始至终操作和读取的都是原子变量本身，所以从代码的角度看，逻辑上是正确的。其次怀疑的是 OpenMP 的实现是否有问题：用 <code>#pragma omp atomic</code> 标注的原子操作是否真的保证了原子性。从反汇编结果可以看到，编译器将这些原子操作生成了 LoongArch64 的 <code>amadd.d</code> 指令，符合预期。为了排查这一点，我们另外设置两个 <code>std::atomic</code> 计数器作为对照，与原来的两个计数器同时使用，观察结果是否一致。结果发现，四个计数器的值（按每轮的增量计算）理应一致，但实际上却呈现出随机的差异。这暗示着，原子加指令会在特定情况下丢失更新。</p>\n<p>但是，用简单的原子加程序测试原子加指令的原子性，并不能复现丢失问题。为了找到最小的复现样例，我们把前述 normaliz 的处理逻辑简化为一个类似的测试程序，同样不能复现这个问题。所以只好在 normaliz 实际运行的代码中，不断注释掉其中的运算步骤，试图找出触发原子加丢失的最小条件。一个诡异的现象是，在注释掉大部分的运算步骤后，问题依然存在。由于程序太复杂，最终还是没能找到一个能够稳定复现原子加丢失的最小代码片段。</p>\n<h2 id=\"第二轮排查\">第二轮排查</h2>\n<p>6 个月后，问题依然没有得到解决。随着 <a href=\"../../../08/18/loongleak-loongbleed/\">LoongLeak/LoongBleed 漏洞的公开</a>，normaliz 中原子加丢失的问题也重新回到我们的视线。这次，我们试图使用 AI 来协助排查。具体使用 AI 的方法是：首先向 AI 指出 normaliz 的上述代码存在死循环问题，要求 AI 确认并复现，然后找出可能原因。在第一轮对话中，AI 注意到了出问题的循环，但并没有得出原子加指令存在问题的结论。此后，我们又向 AI 提示该问题只在 LoongArch 上存在、在其它架构上不存在，AI 依然没能给出明确的结论。最后，我们直接告诉 AI 已经定位到原子加存在问题这一事实，并要求它复现并给出最小复现样例。这轮对话中，AI 最终把目光投向处理函数中的一段 <code>memcpy</code> 调用，而这正是第一轮排查中被忽视的部分：<code>memcpy</code> 的实现位于 glibc 中，glibc 会根据当前可用的硬件特性选择最优实现；如果硬件支持向量指令集（龙架构上是 LSX/LASX），glibc 的 <code>memcpy</code> 就会使用相应的向量指令加速内存搬运。而正是这些向量化的内存搬运，触发了 LoongArch64 上原子加指令丢失的问题。两天后，AI 给出了一个稳定复现问题的最小程序。</p>\n<h2 id=\"问题面的扩大\">问题面的扩大</h2>\n<p>发现原子加指令会出现丢失更新的问题后，我们产生了新的疑问：其一，只有原子加存在问题，还是其它原子指令也存在问题；其二，其它的内存操作是否也会触发类似的问题。</p>\n<p>对于问题一，我们首先排查了 CAS 指令，因为它可用于实现原子加法，很容易判断是否出现问题。结果发现，CAS 指令在相同条件下也存在问题。对于其它原子指令，例如原子交换、原子最大、原子最小、原子按位与、原子按位或等，由于即使发生丢失，也不容易从结果上判断出来，因此一开始并没有验证。例如，原子取最大值的过程中如果发生丢失，那么只要更新最大值的那次操作没有丢失，结果就是正确的。</p>\n<p>经过深入思考，我们最终找到了验证方案：为了检查这类指令是否发生丢失，改为把每次操作的结果都记录下来，事后再做校验。以原子取最大值为例，如果并行地对 1 到 n 这 n 个数进行原子取最大值操作，那么最终的结果应该是 n。每次原子取最大值时，修改内存的同时，还会返回旧的最大值。对于输入为 k 的操作，如果返回的旧值小于 k，则说明此次操作更新了最大值。原子性保证了：所有更新了最大值的操作，其返回值不会出现重复。如果出现了重复，则说明发生了原子指令更新的丢失。经过验证发现，这些原子指令在相同条件下，都会发生丢失。</p>\n<p>对于问题二，我们测试发现，只有 LASX 的向量化读内存操作（<code>xvld</code>）会触发原子指令丢失的问题；而正常的标量读取和 LSX 的向量化读内存操作（<code>vld</code>）则不会触发该问题。后来，<a href=\"https://github.com/CSharperMantle\">Rong \"Mantle\" Bao</a> 独立发现，当原子变量所在的内存地址与被读取的内存地址存在特定的位置关系时，正常的标量读取也可能触发原子指令丢失，意味着即使没有使用 LASX 也可能出现问题，只是概率更小。这些复杂的触发条件，解释了为什么这个问题一直没有被找到。</p>\n<h2 id=\"具体结论\">具体结论</h2>\n<p>在介绍具体结论之前，首先介绍关于此问题的背景知识：龙芯的 3C6000/S 和 3A6000 用的是 LA664 核心，其指令集是 LoongArch64，带有 SIMD 扩展；其中，128 位的 SIMD 扩展叫 LSX，256 位的叫 LASX。较早的 LA464 核心（如 3A5000）没有这个问题。LASX 中存在读取内存指令 <code>xvld</code>，一次可以读取 32 字节到向量寄存器中。龙芯的原子指令可以概括为：<code>am&lt;OP&gt;[_db].&lt;width&gt;</code>，其中 <code>&lt;OP&gt;</code> 表示具体的原子操作，如 <code>amadd</code>、<code>amcas</code>、<code>amswap</code>、<code>ammax</code>、<code>amxor</code>、<code>amand</code>、<code>amor</code> 等；<code>[_db]</code> 表示是否带有 data barrier（db）即数据屏障；而 <code>&lt;width&gt;</code> 表示操作的数据宽度，如 <code>.d</code> 表示 64 位，<code>.w</code> 表示 32 位。</p>\n<p>总结实验结果，复现原子操作丢失需要同时满足以下三个条件：</p>\n<ul>\n<li>线程运行在不同的物理核上（即不能是同一个物理核上的两个 SMT 逻辑核）；</li>\n<li>这些线程对同一地址进行不带数据屏障的原子操作；</li>\n<li>其中至少一个线程在原子操作之间穿插内存读取操作。</li>\n</ul>\n<p>其中，内存读取操作可以是 LASX 的向量化读内存操作 <code>xvld</code>；当被读取的内存地址与原子操作的内存地址满足特定的位置关系时，内存读取操作也可以是普通的标量读取。</p>\n<h2 id=\"复现和测量\">复现和测量</h2>\n<p>最小的复现方法，来自于 AI 对 normaliz 代码的简化。normaliz 每个数据点大小是 2208 字节，即是 276 个 <code>uint64_t</code>。两条线程各自分片遍历这些点，对每个点先做一次向量化的内存搬运（<code>memcpy</code>），再对三个共享计数器各做一次 relaxed 原子加（对应不带数据屏障的 amadd 指令）。一轮结束后，检查三个计数器是否相等，不相等就说明丢失了更新。</p>\n<p>在 3C6000/S 上，用两个不同物理核（比如 CPU0 和 CPU2）、每个点 2208 字节、每次试验 200 轮、共 30 次试验，得到如下结果：</p>\n<table>\n<thead>\n<tr>\n<th>原子操作</th>\n<th style=\"text-align: right;\">双方都做 LASX 拷贝</th>\n<th style=\"text-align: right;\">双方都做 LASX 读</th>\n<th style=\"text-align: right;\">单侧 LASX 拷贝</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>amadd.d</code></td>\n<td style=\"text-align: right;\">67%</td>\n<td style=\"text-align: right;\">100%</td>\n<td style=\"text-align: right;\">53%</td>\n</tr>\n<tr>\n<td><code>amadd.w</code></td>\n<td style=\"text-align: right;\">73%</td>\n<td style=\"text-align: right;\">100%</td>\n<td style=\"text-align: right;\">67%</td>\n</tr>\n<tr>\n<td><code>amcas.d</code></td>\n<td style=\"text-align: right;\">77%</td>\n<td style=\"text-align: right;\">97%</td>\n<td style=\"text-align: right;\">17%</td>\n</tr>\n<tr>\n<td><code>amcas_db.d</code></td>\n<td style=\"text-align: right;\">0%</td>\n<td style=\"text-align: right;\">0%</td>\n<td style=\"text-align: right;\">0%</td>\n</tr>\n<tr>\n<td><code>ammax.d</code></td>\n<td style=\"text-align: right;\">43%</td>\n<td style=\"text-align: right;\">100%</td>\n<td style=\"text-align: right;\">50%</td>\n</tr>\n<tr>\n<td><code>amswap.d</code></td>\n<td style=\"text-align: right;\">53%</td>\n<td style=\"text-align: right;\">100%</td>\n<td style=\"text-align: right;\">53%</td>\n</tr>\n</tbody>\n</table>\n<p>表里的百分比是“30 次试验中失败的试验比例”。可以看到“双方都做 LASX 读”最容易触发问题，触发概率几乎到 100%；带 db 的 <code>amcas_db.d</code> 在同样条件下总是 0%。</p>\n<h2 id=\"插曲为什么-aosc-后来复现不了了\">插曲：为什么 AOSC 后来复现不了了</h2>\n<p>在复现这个问题的过程中，有一个小插曲，也是整件事里最有意思的地方。在 2 月刚发现这个问题时，AOSC OS 和 Debian 都能复现 normaliz 的死循环问题。但是到了 8 月重新排查时，AOSC 那边却怎么都复现不出来，而 Debian 照旧。当时我们并不知道为什么会出现这种不一致，只是继续在 Debian 上做实验。</p>\n<p>后来，随着 AI 定位到问题出在 <code>memcpy</code>，我们才明白了其中的原因。AOSC 在 2 月份之后发布的 Core 13 版本在 glibc 里错误地关掉了 <code>--enable-multi-arch</code> 选项，于是系统 <code>memcpy</code> 不再走 LASX 加速路径；而 Debian 的 glibc 正常启用向量加速，因此 <code>memcpy</code> 会使用 LASX。2 月份的时候，AOSC 和 Debian 都使用 LASX 加速路径；而到了 8 月，AOSC 的 <code>memcpy</code> 不再使用 LASX 加速，自然就触发不了。在 Debian 上，用 <code>GLIBC_TUNABLES=glibc.cpu.hwcaps=-LASX</code> 关掉 LASX 加速，问题也不再触发。</p>\n<p>所以等 AOSC 发布 Core 14 版本，重新打开 <code>--enable-multi-arch</code> 选项后，问题也会重新复现。考虑到 <code>memcpy</code> 很常用，受影响的程序可能比我们想象的还要多，只是因为触发概率较小，难以发现。</p>\n<h2 id=\"影响面分析\">影响面分析</h2>\n<p>存在问题的原子指令中，<code>ammax</code>、<code>ammin</code> 等指令由于目前 C 标准中没有对应的原子操作接口，所以很难被编译器生成出来；而 <code>amcas</code> 属于 LoongArch64 v1.1 的新增指令，因此在默认情况下也不会被编译器生成。可能存在较大影响的是 <code>amadd</code>，即原子加指令。该指令通常会被用于引用计数：如果引用计数的增加操作丢失，计数就会小于实际引用数，可能导致对象被提前释放，从而引发 use-after-free 或双重释放等内存安全问题。而触发的另一个条件，即向量化内存读取，则很容易被 <code>memcpy</code> 之类的函数触发。我们发现，在 Rust 标准库中，<code>std::sync::Arc</code> 的引用计数、<code>std::sync::mpsc</code> 的 <code>Sender</code> 克隆也都采用了不带数据屏障的 <code>amadd</code> 指令。我们构造了 safe Rust 程序，使用 <code>Arc</code> 或者 <code>mpsc</code> 都能让程序崩溃，表现为 SIGABRT 或 glibc 报告堆被破坏，这意味着出现了 use-after-free。</p>\n<p>但是，该问题很难被用于安全攻击。因为要触发该问题，两个线程必须在同一个对象的同一个计数器上并发执行 relaxed 原子操作，而且至少有一方在执行向量化内存读取。这种触发条件意味着潜在攻击者与受害者必须处于同一进程内，无法跨越进程隔离，因此很难被单方面利用。</p>\n<h2 id=\"规避方法\">规避方法</h2>\n<p>一般而言，由于在高级语言代码中，开发者对编译器产生的原子指令并无控制能力，因此对应用软件的开发者而言，并无直接的规避手段。在软件层面的规避方法，主要通过编译器实现，即编译器不再生成不带数据屏障的原子指令（<code>am&lt;OP&gt;.*</code>），而是生成带有数据屏障的原子指令（<code>am&lt;OP&gt;_db.*</code>），或者使用 LL/SC 循环来实现原子操作。但对于目前已经存在的二进制程序而言，则需要完全重新编译才能应用这些规避方法。因此，从软件层面上规避的代价很高昂。</p>\n<h2 id=\"修复\">修复</h2>\n<p>向龙芯反馈后，修复来得很快：2026 年 8 月 26 日我们发邮件把问题反馈给龙芯，仅仅两周后的 2026 年 9 月 9 日就拿到了测试固件，3A6000 和 3C6000/S 实测都恢复了正常。龙芯告诉我们，这个固件预计会在国庆节（10 月 1 日）之前发布。</p>\n<p>修复方式是将 MCSR24 的 bit 13 置为 1。MCSR24 是一个内部的 CSR，手册中并未说明其功能。设置这个 bit 之后，丢失更新的问题不再出现。经测试，性能损失很小：单核性能没有受到影响，多核性能只是略微下降。</p>\n<p>如果受影响用户暂时不能更新固件，也可以选择在 Linux 内核里直接写入该 bit，这样等效于完成固件修复，不需要等待主板固件更新。</p>\n<h2 id=\"总结\">总结</h2>\n<p>回过头来看，这个故事起源于一个纯软件的问题：打包时出现的死循环、偶尔算错的计数器。到最后却发现是 CPU 里的一条原子加指令，它并不原子。从发现问题到找出原因前后跨越了半年时间，其中真正有效的推进只在两天里完成，AI 和人都有不可或缺的作用。剩下的时间就是确认问题、找到触发条件、扩大测试面，等待固件修复。</p>\n<p>事实上，类似的 erratum 在各家厂商的 CPU 中都很常见。感兴趣的读者可以翻阅 ARM 公版核的 Software Developer Errata Notice，其中不少涉及访存指令或原子指令，个别严重的甚至会导致 CPU 死锁；但真正影响到用户使用体验的其实非常少。这类问题，与其让它在未来的某一天于某个复杂系统中以一次不稳定的报错突然冒出来，不如尽早定位到具体原因并加以修复。</p>\n<h2 id=\"致谢\">致谢</h2>\n<p>这项工作由王邈发起并主导，我负责复现和报告整理。在我们告知 <code>amcas</code> 也存在问题之后，<a href=\"https://github.com/CSharperMantle\">Rong \"Mantle\" Bao</a> 又发现了类似的 CPU 问题，并一并得到了修复。感谢龙芯芯片研发部和开发者社区运营部等部门在报告和修复过程中高效而专业的表现！</p>","date_modified":"2026-09-24T00:00:00+00:00","date_published":"2026-09-24T00:00:00+00:00","id":"https://jia.je/hardware/2026/09/24/loongson-cpu-erratum/","image":null,"tags":["cpu","erratum","hardware","loongarch","loongson"],"title":"一颗 CPU 的原子指令，一个打包死循环：LA664 丢失更新事件始末","url":"https://jia.je/hardware/2026/09/24/loongson-cpu-erratum/"},{"authors":[],"content_html":"<h1 id=\"智算卡生态进校园之我见\">智算卡生态进校园之我见</h1>\n<h2 id=\"背景\">背景</h2>\n<p>最近频繁地和各家智算卡（GPU、NPU，或者统称为 xPU）厂商交流，讨论如何培养软件生态、如何进入校园。同样的观点我已经跟不同的人讲过至少五遍了，索性写成一篇博客，一次讲清楚。</p>\n<!-- more -->\n\n<h2 id=\"大背景\">大背景</h2>\n<p>故事的背景并不难理解：国内算力需求旺盛，而英伟达又难以进入，于是无论是国产厂商，还是非英伟达的海外厂商，都在设法培育国内市场。而培育市场特别关键的一步，就是培育生态。</p>\n<p>由于我在学校里参与了多门课程的教学，接触到的也多是厂商里负责校园生态对接的员工，因此经常和他们聊起一个问题：怎样把这些算力卡的生态带进校园。国内庞大的算力需求，最终总要有人把它部署起来、用起来；而选哪家卡、能不能把卡的算力真正发挥出来，对从业者的知识储备是有要求的。如果能在学校里提前为企业培养所需的人才，生态就有机会从企业扩展到高校乃至更广的人群，这是厂商最核心的诉求。</p>\n<p>在交流的过程中，我也从学校和公司的双重角度，分析过生态可以在校园的哪些环节切入，并向他们提了不少来自学校视角、他们目前尚未顾及的看法。这篇博客就把我的想法分享出来，供国内外各家计算卡厂商参考：如果你们想把硬件或生态推广到校园里，可以走哪些路。这些想法我不藏着掖着，全部公开写在这里。事实上，只要对学校足够理解，任何人都能得出类似的分析；真正拉开差距的，是哪家公司更有魄力，愿意真正从学校的需求和学生的需求出发，把生态这样一个长期推广项目踏实做下去，从而抢占市场先机。这也许是潜在读者最该思考的一点。下面只谈我个人的观点。</p>\n<h2 id=\"现状\">现状</h2>\n<p>先看现状。目前校园里与算力卡相关的课程，显然还是以 GPU、更准确地说以英伟达的 GPU 为主。真正需要实际用到 GPU 的课程其实并不算多：主要是高性能计算方向，以及近几年新开的、与大模型紧密相关的课程，或许还有图形学等。这些课程往往有平台上的惯性：助教和老师过去就用英伟达平台，英伟达本身又足够成熟，于是就这么延续了下来。</p>\n<p>所以，目前的市场生态仍牢牢握在英伟达手中。这倒不是说英伟达在学校投了多少人力，而是长达二十年的积累给了它巨大的先发优势。即便如今卡不好买、也未必有人来和学校谈合作，对学校而言，务实的选择仍然是尽量弄到能买到的英伟达卡，提供给学生做教学。</p>\n<p>但这个现状终将改变。一方面是不好买，另一方面是大家越来越不愿意用，于是无论国内还是海外的非英伟达生态，都被列入了备选，倒不一定要立刻替换英伟达，毕竟手里的 V100、A100，甚至 4090 这类游戏卡，还能再用很久。等这批机器几年后彻底淘汰，如果那时仍然买不到好的英伟达智算卡，就不得不转向其他方案了。</p>\n<p>而眼下这几年，恰好是一个窗口期：各家厂商都在努力推广自己的生态，校园确实是重要的切入点。毕竟无论是生产制造 xPU 的公司，还是下游使用这些卡的公司，其人才都有相当一部分来自学校。在校园层面做推广，规模相对可控，对招聘也有好处。</p>\n<p>当然，学校有学校的特点，这往往是厂商从公司视角很难设身处地去体会的。我写这篇博客，也是想提供一个来自学校老师和学生视角的看法，给这些公司一些建议，看看有没有哪家愿意真正把这些事情落地，真心实意地做生态推广，而不是为了应付 KPI。</p>\n<h2 id=\"学校的特点\">学校的特点</h2>\n<p>既然谈到学校，就先谈学校的特点。</p>\n<p>学校里授课的主体是老师。老师讲授的内容，一部分来自自己的研究，做研究的老师，往往更倾向于开设与研究方向对应的课程；此外还有一些大家都认为应当开设的基础课程。而在设备选择上，学校有很多考量。</p>\n<p><strong>第一是经费。</strong> 如今大模型如此赚钱，把卡卖给企业做推理所能带来的收益，远高于放在学校里做教学。学校也很难专门为教学拨出大笔经费去买卡，更多是\"为科研买卡时顺便服务教学\"。如果没有科研需求，教学就更难买得起这些设备了。这是第一道门槛。</p>\n<p><strong>第二是严谨与公平。</strong> 教学环境需要足够的稳定，不能中途突然宕机，如果恰好在作业截止日期前出问题，后果会很严重。换句话说，教学实验环境要足够可靠，不要求多少个九，但绝不能在关键节点、尤其是截止日期或考试期间掉链子。因此，教学材料最好是离线的、部署在校内的，而不是放在云端。云端看似可用性更好，实际上网络瓶颈不少；更关键的是，本地机器出了问题可以随时派人去修，远程则时间不可控，老师们会缺乏安全感。这是很重要的一点差异。</p>\n<p><strong>第三是经费的使用方式。</strong> 学校的经费往往倾向于买设备，却很难用来买服务。在一些算力需求大的企业里，厂商会派团队驻场做技术支持，这种模式在企业里行得通，但在学校里很难维持：学校没有这样的经费科目，去买服务，就像我们之前想采购大量云服务一样困难。结合上面提到的可靠性问题，课程最理想的环境是：<strong>离线、线下、可靠</strong>，同时又因为缺少技术支持而必须足够好用、开箱即用。比如插上卡、装个驱动就能用，不需要找人申请权限、等人给文档。如果做不到这一点，对生态其实是相当不利的。</p>\n<p><strong>第四是老师的主导性。</strong> 一些学校很强调老师在课程中的主导地位。比如我们学校的一些课程会有企业参与、算力支持，但主导的仍是以老师加助教组成的教学团队，不会做太多商业化的、打广告式的内容，这方面一定是有所限制的。</p>\n<p>于是你会看到，学校和厂商的需求往往是相悖的：</p>\n<ul>\n<li>学校想要硬件，厂商却没有那么多富余硬件，卡都要卖给急需算力、能赚钱的地方，学校显然不那么赚钱；</li>\n<li>厂商说可以把卡放到云端提供，学校又缺乏安全感，担心哪天云服务出问题，出现不可控的情况；</li>\n<li>一些智算卡在使用上还设计了保密机制，必须由专门的工程师授权才能访问资料，这对学校来说也是很大的扣分项。</li>\n</ul>\n<p>这里列举了很多困难，归根结底来自学校作为事业单位与企业作为盈利组织在性质上的差异。但这并非不可调和的矛盾。生态建设本身就是一件非常长期主义、且不太赚钱的事。换句话说，企业里做生态的人，本就和 KPI、和挣钱的目标不太兼容。只有企业愿意把做生态真正长期化，才可能和学校同频。否则结果往往是：公司为了 KPI，员工也为了 KPI，拼命往校园里塞广告，而这恰恰是学生最不愿意看到的，学生不高兴，给老师打低分，老师也是输家，厂商多半也没讨到好。</p>\n<p>说了这么多困难，接下来该讲\"扬\"的部分了：厂商为什么要花这么大力气在校园里推广生态，它能带来什么，又可以从哪些方面入手。</p>\n<h2 id=\"如何从课程入手\">如何从课程入手</h2>\n<p>想到智算卡生态进校园，大家的第一反应通常都是课程。但课程对卡的需求，其实差异很大，就像社会上的各类人对卡的需求也很不一样。</p>\n<p><strong>最浅的一层，是\"只用算力、不关心卡\"的人。</strong> 他们要的只是算力，用的是 PyTorch 这样非常上层的软件及其之上的生态，兼容性极好，换张卡，代码几乎不用改，重装一套环境就行。对这类需求，推动难度很小，但收益同样有限。比如我们系不少课程里都有用到 AI 的环节，但使用者并不直接碰 AI，而是通过网页或 App 间接使用。你可以告诉他\"这个网站背后用的是某家的卡\"，让他有个印象，但因为没真正上手，印象也不会太深。这类课程其实很多，包括一些计算机入门课，尤其是面向外系的课程，会吸引大量非计算机专业的同学使用 AI。对他们来说，最主要的收获就是：<strong>这张卡确实能用，用起来和英伟达没什么区别。</strong></p>\n<p>这一点看起来不大，短期也未必有效果，这类用户粘性很差，对他而言用什么卡都一样，无非多了一个\"某家的卡用起来和英伟达没差\"的印象。但未来某天，当他参与某家企业或单位的采购决策时，可能会想起自己当年上过这门课、真正摸过这块硬件，并意识到：在某些场景下，这张智算卡确实可以替代主流国际品牌，评估结论是可以用。这就是一种非常长期、潜移默化的用户观念培养，短期之内不会有任何效果。</p>\n<p><strong>再深一层，是重度使用智算卡的同学。</strong> 比如清华最近新开的一些课程（比如交叉信息院的大模型组成原理、计算机系的高级机器学习），要用一个学期把大模型的训练流程完整走一遍。虽然用的也是 PyTorch 这类上层生态，但他们会长时间亲手与卡打交道，看利用率、看多卡表现等等，尽管不强调太多优化，也会有具体的使用感受。这些同学能作为真实用户较深入地体验智算卡，理解它好在哪、不好在哪，从而积累大量第一手经验。而且他们未来很可能进入本就依赖算力的企业岗位，把课程中积累的经验迁移到工作中，这会在一定程度上影响采购决策，或促进后续的算力落地，是很不错的切入角度。</p>\n<p>这类课程相对较新，英伟达的包袱或传统没那么深；在算力紧缺的背景下，又需要课程内完成一件相对算力密集的事情，自然比那些能在单机上用 CPU 跑的小应用更依赖算力；课程新、有算力需求、硬件又昂贵，同时还没有形成很强的英伟达壁垒，因此新的计算卡相对容易进入这样的课程。</p>\n<p><strong>再往下一层，是真正与 GPU 深入打交道的课程</strong>，尤其是 GPU 编程和并行计算。这类课程的内容本身就大量贴合英伟达 GPU 的结构与编程方式，对口的是算子编程、编译等领域所需的人才，而算子与编译器生态恰恰是当前生态建设中很重要的一环。所以这些课程非常重要，但也没那么容易切入：一旦把 GPU 换成其他计算卡，编程模型会有不少变化。要做算子级别的编程，就不可避免地触及大量细节，这对老师和助教的知识储备要求很高，他们得有足够的使用经验，才愿意、也才敢开这门课。</p>\n<p>一个利好是，一些国产智算卡可能早已部署在超算等领域，也有很多科研项目在上面开展。也就是说，不少课题组里的老师和博士生，其实已经积累了大量与这些智算卡\"搏斗\"的经验，或许有能力去改动课程内容，毕竟改动幅度不小。但关键在于，怎样让他们有足够的动力去推动这个变化，因为他很容易产生路径依赖：讲了这么多年英伟达，突然要在英伟达之外加入另一种智算卡，学生愿不愿意学？可行的做法是先从小班实验、让同学自愿报名开始，再慢慢扩大。长期来看，这一定能培养出一批懂系统、做 AI Infra 的人才。</p>\n<p><strong>最深的一层，是硬件本身。</strong> 国内这些课程，主要还是由做科研的老师开设的专业课。但无论国内还是国外，xPU 硬件方向的科研和业界都有较大脱节，因此很难在老师中找到做计算卡硬件的人，至少计算机系里很少，或许集成电路学院能找到。这种情况下，既难找到也难开设相关课程：老师要花大量精力去学，未必有信心开；若直接由企业来开，内容又太局限于某一款具体型号的架构，公司色彩过重，不太适合校园氛围。</p>\n<p>所以这一层对老师的要求极高，而这恰恰是智算卡厂商非常需要的人才。前阵子廖博发了一个视频，主要讲体系结构人才的缺口：CPU 有问题，GPU 其实问题一样多。高校在这方面的人才培养，我觉得是有所不足的，确实存在空缺。这个空缺一部分来自缺失的课程，一部分来自缺失的科研，而两者本是一体的。解决它需要全链路地推进：先打通企业界与学术界的壁垒，因为现在企业做的东西和学校、科研做的东西已经相当割裂。只有放出一些课题交给学术界去做、能够发论文，才会有老师愿意投入这方面的科研，进而拿到项目、开出课程。这是一个非常长期的人才培养周期，但反过来也能帮企业把入职后的培养前移到本科或研究生阶段。</p>\n<p>我大致从这四类课程分析了智算卡生态如何进入校园。其实这四类也正是社会人群的缩影：只用 AI、不关心用什么卡的；使用高层工具的；深入到算子的；深入到硬件的。这些课程对应着不同的需求，而其中的道理不仅适用于课程，也适用于社会上的各类人群。</p>\n<h2 id=\"如何从竞赛入手\">如何从竞赛入手</h2>\n<p>除了课程，另一个重要的抓手是竞赛。这也是当前许多智算卡厂商优先切入的方向，因为竞赛门槛相对低一些，但也确实鱼龙混杂，各种层次、各种质量的比赛非常多。</p>\n<p>首先，比赛能很好地激励学生，尤其是学有余力的学生去探索课外内容，再通过奖金、保研加分等激励，促使他们有动力参赛。而参赛本身，就是在为生态建设出一份力：要算子人才就办算子竞赛，要硬件人才就办硬件比赛，要应用人才就办应用竞赛。总之，这是相对容易定制、也容易举办的赛事。</p>\n<p>主要的难点在于定位与赛务：怎样定位这场比赛、怎样把它办起来、怎样把你想要的人请进来。比赛不是给钱赞助就完事了，赛务决定了它的成败。办得好，能为行业和公司输送新鲜血液，也能给学生提供上升通道，让他愿意投入这个行业去学习和奋斗；办得不好，反而会影响公司声誉。所以，办比赛本身不难，难的是愿意花时间精力把它办好，这同样是一件需要长期主义的事。</p>\n<p>每到这时我就要举龙芯杯的例子。今年正好是龙芯杯十周年，我作为往届选手参加了在西安的十周年活动。过程中我最深的感受是，龙芯公司和各位老师都非常投入。各位老师一开始是义务劳动，想推广国内的组成原理与 CPU 课程；到后来，龙芯发挥了很大作用，他们的教育事业部对这个活动的投入非常大。且不说投入了多少奖金，单看投入的人力、请来的众多专家费心费力地把比赛办好：保证公正、高效，提供良好的参赛和办赛体验，让学生学到知识，同时对公司的招聘和学生的发展都有帮助，这就已经非常难得。但要看到，这是靠十年的努力，一年一年投入积累出来的。十年是很长的时间，而公司里人员流动性往往很高。如何长期维持一支专业团队，去服务比赛的公平性，让大家相信作弊一定会被惩罚，相信平台不会成为比赛的瓶颈……这背后有大量隐性的时间和金钱成本。</p>\n<p>因此我也建议厂商先从竞赛入手，感受一下如何与学生、老师打交道，再考虑与课程合作。竞赛门槛较低，声音也容易做大；但要持续做好，可能比课程更难。因为在课程里，真正把课做好的是学校的老师和助教；而在比赛中，如果连公司自己人都不愿意、或不觉得要把比赛办好，那还有谁能把它办好？比赛做砸了，最终损失的是自己的名誉。</p>\n<h2 id=\"一点题外话\">一点题外话</h2>\n<p>除了与本科教育紧密相关的内容，我也聊了很多其他方面的生态培养。</p>\n<p>比如，为什么英伟达的生态大家觉得好？因为它门槛确实低：随便买张卡、装个驱动就能用。但很多智算卡是\"有人想用却用不了\"：要么买不到卡，要么买了之后要签各种保密协议，不让用、不让往外说，装个软件还得找人。这些做法非常伤害\"散户\"生态。对一买就是几百上千张卡的大客户，你派人驻场当然可以；但如果你的目标不止于此，而是想和英伟达竞争、把生态推广到更广的范围，那你的追求就不该是这样。</p>\n<p>你应当把东西做得非常可用、门槛足够低、足够开放，让用户在 90% 的日常使用中不需要和你的任何人沟通，自己买卡、自己从网上获取资料，就能很好地用起来。这是长期要做的功课。短期内，国产智算卡要迈出的第一步，是先让用户觉得\"这东西能用、靠谱\"，愿意把它当作英伟达的一个下位替代，至少先做到\"可替代\"，再谈进一步的事情。下一步，才是去谈超越英伟达：和你一样好用，甚至更好用、更容易用，在某些方面比你做得更好，这才是未来的方向。</p>\n<h2 id=\"总结\">总结</h2>\n<p>最后总结一下：生态想进校园，一定得让学校的人和公司的人想到一起去；否则目标不同，就常常会出现分歧。也希望各家计算卡越做越好，能撑起英伟达之外的市场。</p>","date_modified":"2026-09-22T00:00:00+00:00","date_published":"2026-09-22T00:00:00+00:00","id":"https://jia.je/misc/2026/09/22/xpu-in-campus/","image":null,"tags":["education","gpu","misc","npu","tsinghua","xpu"],"title":"智算卡生态进校园之我见","url":"https://jia.je/misc/2026/09/22/xpu-in-campus/"},{"authors":[],"content_html":"<h1 id=\"修复绿联-ug307-95348-hdmi-采集卡清晰度与颜色问题\">修复绿联 UG307-95348 HDMI 采集卡清晰度与颜色问题</h1>\n<h2 id=\"背景\">背景</h2>\n<p><a href=\"../../../../../misc/2026/09/11/classroom-routing/\">上文</a> 提到，我打算用采集卡来录制鸿蒙电脑的输出，作为 OBS 的输入来做软件导播，用的采集卡型号是<a href=\"https://www.lulian.cn/product/1537.html\">采用了 MS2130S 芯片的绿联 UG307-95348 采集卡</a>，采集来自 MateBookPro 的显示输出。在使用过程中，遇到了清晰度和颜色的问题，下面介绍我是怎么研究和解决的。</p>\n<!-- more -->\n\n<h2 id=\"清晰度问题\">清晰度问题</h2>\n<p>首先是遇到了清晰度问题，在 macOS 上为 OBS 设置采集卡输入时，需要关闭 Use Preset 选项，选择 <code>3840x2160 (16:9) - 30, 60 FPS - CS 709 - NV12 (420v)</code>，而不是 <code>3840x2160 (16:9) - 30 FPS - CS 709 - NV12 (420v)</code>。后者明显更糊，尽管从名称上看似乎只差一个帧率。如果勾选了 Use Preset，分辨率选 <code>3840x2160</code>，效果和上面第二种 4K 选项一样，也有些糊。</p>\n<p>用下面这个 Swift 脚本打印采集卡的各种信息，可以发现 60 FPS 的那个版本经过了 MJPEG 压缩，从 dmb1 字段即可看出：</p>\n<div class=\"language-shell highlight\"><pre><span></span><code><span id=\"__span-0-1\"><a id=\"__codelineno-0-1\" name=\"__codelineno-0-1\" href=\"#__codelineno-0-1\"></a>$<span class=\"w\"> </span>swift<span class=\"w\"> </span>list_formats.swift\n</span><span id=\"__span-0-2\"><a id=\"__codelineno-0-2\" name=\"__codelineno-0-2\" href=\"#__codelineno-0-2\"></a><span class=\"w\">  </span>3840x2160<span class=\"w\">  </span>420v<span class=\"w\">  </span><span class=\"nv\">fps</span><span class=\"o\">=</span><span class=\"m\">30</span>.0..30.0<span class=\"w\">  </span><span class=\"nv\">dur</span><span class=\"o\">=</span><span class=\"m\">33333</span>..33333us\n</span><span id=\"__span-0-3\"><a id=\"__codelineno-0-3\" name=\"__codelineno-0-3\" href=\"#__codelineno-0-3\"></a><span class=\"w\">      </span>ext<span class=\"w\"> </span><span class=\"nv\">CVImageBufferColorPrimaries</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span>ITU_R_709_2\n</span><span id=\"__span-0-4\"><a id=\"__codelineno-0-4\" name=\"__codelineno-0-4\" href=\"#__codelineno-0-4\"></a><span class=\"w\">      </span>ext<span class=\"w\"> </span><span class=\"nv\">CVImageBufferTransferFunction</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span>SMPTE_240M_1995\n</span><span id=\"__span-0-5\"><a id=\"__codelineno-0-5\" name=\"__codelineno-0-5\" href=\"#__codelineno-0-5\"></a><span class=\"w\">      </span>ext<span class=\"w\"> </span><span class=\"nv\">CVImageBufferYCbCrMatrix</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span>ITU_R_709_2\n</span><span id=\"__span-0-6\"><a id=\"__codelineno-0-6\" name=\"__codelineno-0-6\" href=\"#__codelineno-0-6\"></a><span class=\"w\">  </span>3840x2160<span class=\"w\">  </span>420v<span class=\"w\">  </span><span class=\"nv\">fps</span><span class=\"o\">=</span><span class=\"m\">60</span>.0..60.0<span class=\"w\">  </span><span class=\"nv\">dur</span><span class=\"o\">=</span><span class=\"m\">16667</span>..16667us<span class=\"w\">  </span><span class=\"nv\">fps</span><span class=\"o\">=</span><span class=\"m\">30</span>.0..30.0<span class=\"w\">  </span><span class=\"nv\">dur</span><span class=\"o\">=</span><span class=\"m\">33333</span>..33333us\n</span><span id=\"__span-0-7\"><a id=\"__codelineno-0-7\" name=\"__codelineno-0-7\" href=\"#__codelineno-0-7\"></a><span class=\"w\">      </span>ext<span class=\"w\"> </span><span class=\"nv\">CVImageBufferColorPrimaries</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span>ITU_R_709_2\n</span><span id=\"__span-0-8\"><a id=\"__codelineno-0-8\" name=\"__codelineno-0-8\" href=\"#__codelineno-0-8\"></a><span class=\"w\">      </span>ext<span class=\"w\"> </span><span class=\"nv\">CVImageBufferTransferFunction</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span>SMPTE_240M_1995\n</span><span id=\"__span-0-9\"><a id=\"__codelineno-0-9\" name=\"__codelineno-0-9\" href=\"#__codelineno-0-9\"></a><span class=\"w\">      </span>ext<span class=\"w\"> </span><span class=\"nv\">CVImageBufferYCbCrMatrix</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span>ITU_R_709_2\n</span><span id=\"__span-0-10\"><a id=\"__codelineno-0-10\" name=\"__codelineno-0-10\" href=\"#__codelineno-0-10\"></a><span class=\"w\">      </span>ext<span class=\"w\"> </span>com.apple.cmio.format_extension.decompressed_from_format_type<span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span><span class=\"m\">1684890161</span><span class=\"w\"> </span><span class=\"o\">(</span>dmb1<span class=\"o\">)</span>\n</span></code></pre></div>\n<p>对应的 Swift 源码：</p>\n<div class=\"language-swift highlight\"><pre><span></span><code><span id=\"__span-1-1\"><a id=\"__codelineno-1-1\" name=\"__codelineno-1-1\" href=\"#__codelineno-1-1\"></a><span class=\"kd\">import</span><span class=\"w\"> </span><span class=\"nc\">AVFoundation</span>\n</span><span id=\"__span-1-2\"><a id=\"__codelineno-1-2\" name=\"__codelineno-1-2\" href=\"#__codelineno-1-2\"></a><span class=\"kd\">import</span><span class=\"w\"> </span><span class=\"nc\">CoreMedia</span>\n</span><span id=\"__span-1-3\"><a id=\"__codelineno-1-3\" name=\"__codelineno-1-3\" href=\"#__codelineno-1-3\"></a>\n</span><span id=\"__span-1-4\"><a id=\"__codelineno-1-4\" name=\"__codelineno-1-4\" href=\"#__codelineno-1-4\"></a><span class=\"kd\">func</span><span class=\"w\"> </span><span class=\"nf\">fourcc</span><span class=\"p\">(</span><span class=\"kc\">_</span><span class=\"w\"> </span><span class=\"n\">v</span><span class=\"p\">:</span><span class=\"w\"> </span><span class=\"n\">FourCharCode</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"p\">-&gt;</span><span class=\"w\"> </span><span class=\"nb\">String</span><span class=\"w\"> </span><span class=\"p\">{</span>\n</span><span id=\"__span-1-5\"><a id=\"__codelineno-1-5\" name=\"__codelineno-1-5\" href=\"#__codelineno-1-5\"></a><span class=\"w\">  </span><span class=\"kd\">let</span><span class=\"w\"> </span><span class=\"nv\">b</span><span class=\"p\">:</span><span class=\"w\"> </span><span class=\"p\">[</span><span class=\"nb\">UInt8</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"p\">=</span><span class=\"w\"> </span><span class=\"p\">[</span>\n</span><span id=\"__span-1-6\"><a id=\"__codelineno-1-6\" name=\"__codelineno-1-6\" href=\"#__codelineno-1-6\"></a><span class=\"w\">    </span><span class=\"nb\">UInt8</span><span class=\"p\">((</span><span class=\"n\">v</span><span class=\"w\"> </span><span class=\"o\">&gt;&gt;</span><span class=\"w\"> </span><span class=\"mi\">24</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">&amp;</span><span class=\"w\"> </span><span class=\"mi\">255</span><span class=\"p\">),</span><span class=\"w\"> </span><span class=\"nb\">UInt8</span><span class=\"p\">((</span><span class=\"n\">v</span><span class=\"w\"> </span><span class=\"o\">&gt;&gt;</span><span class=\"w\"> </span><span class=\"mi\">16</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">&amp;</span><span class=\"w\"> </span><span class=\"mi\">255</span><span class=\"p\">),</span>\n</span><span id=\"__span-1-7\"><a id=\"__codelineno-1-7\" name=\"__codelineno-1-7\" href=\"#__codelineno-1-7\"></a><span class=\"w\">    </span><span class=\"nb\">UInt8</span><span class=\"p\">((</span><span class=\"n\">v</span><span class=\"w\"> </span><span class=\"o\">&gt;&gt;</span><span class=\"w\"> </span><span class=\"mi\">8</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">&amp;</span><span class=\"w\"> </span><span class=\"mi\">255</span><span class=\"p\">),</span><span class=\"w\"> </span><span class=\"nb\">UInt8</span><span class=\"p\">(</span><span class=\"n\">v</span><span class=\"w\"> </span><span class=\"o\">&amp;</span><span class=\"w\"> </span><span class=\"mi\">255</span><span class=\"p\">),</span>\n</span><span id=\"__span-1-8\"><a id=\"__codelineno-1-8\" name=\"__codelineno-1-8\" href=\"#__codelineno-1-8\"></a><span class=\"w\">  </span><span class=\"p\">]</span>\n</span><span id=\"__span-1-9\"><a id=\"__codelineno-1-9\" name=\"__codelineno-1-9\" href=\"#__codelineno-1-9\"></a><span class=\"w\">  </span><span class=\"kd\">let</span><span class=\"w\"> </span><span class=\"nv\">s</span><span class=\"w\"> </span><span class=\"p\">=</span><span class=\"w\"> </span><span class=\"nb\">String</span><span class=\"p\">(</span><span class=\"n\">bytes</span><span class=\"p\">:</span><span class=\"w\"> </span><span class=\"n\">b</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"n\">encoding</span><span class=\"p\">:</span><span class=\"w\"> </span><span class=\"p\">.</span><span class=\"n\">ascii</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"p\">??</span><span class=\"w\"> </span><span class=\"s\">\"?\"</span>\n</span><span id=\"__span-1-10\"><a id=\"__codelineno-1-10\" name=\"__codelineno-1-10\" href=\"#__codelineno-1-10\"></a><span class=\"w\">  </span><span class=\"k\">return</span><span class=\"w\"> </span><span class=\"n\">s</span><span class=\"p\">.</span><span class=\"n\">allSatisfy</span><span class=\"w\"> </span><span class=\"p\">{</span><span class=\"w\"> </span><span class=\"nv\">$0</span><span class=\"p\">.</span><span class=\"n\">isLetter</span><span class=\"w\"> </span><span class=\"o\">||</span><span class=\"w\"> </span><span class=\"nv\">$0</span><span class=\"p\">.</span><span class=\"n\">isNumber</span><span class=\"w\"> </span><span class=\"p\">}</span><span class=\"w\"> </span><span class=\"p\">?</span><span class=\"w\"> </span><span class=\"n\">s</span><span class=\"w\"> </span><span class=\"p\">:</span><span class=\"w\"> </span><span class=\"nb\">String</span><span class=\"p\">(</span><span class=\"n\">format</span><span class=\"p\">:</span><span class=\"w\"> </span><span class=\"s\">\"0x%08x\"</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"n\">v</span><span class=\"p\">)</span>\n</span><span id=\"__span-1-11\"><a id=\"__codelineno-1-11\" name=\"__codelineno-1-11\" href=\"#__codelineno-1-11\"></a><span class=\"p\">}</span>\n</span><span id=\"__span-1-12\"><a id=\"__codelineno-1-12\" name=\"__codelineno-1-12\" href=\"#__codelineno-1-12\"></a>\n</span><span id=\"__span-1-13\"><a id=\"__codelineno-1-13\" name=\"__codelineno-1-13\" href=\"#__codelineno-1-13\"></a><span class=\"kd\">let</span><span class=\"w\"> </span><span class=\"nv\">session</span><span class=\"w\"> </span><span class=\"p\">=</span><span class=\"w\"> </span><span class=\"bp\">AVCaptureDevice</span><span class=\"p\">.</span><span class=\"n\">DiscoverySession</span><span class=\"p\">(</span>\n</span><span id=\"__span-1-14\"><a id=\"__codelineno-1-14\" name=\"__codelineno-1-14\" href=\"#__codelineno-1-14\"></a><span class=\"w\">  </span><span class=\"n\">deviceTypes</span><span class=\"p\">:</span><span class=\"w\"> </span><span class=\"p\">[.</span><span class=\"n\">external</span><span class=\"p\">],</span>\n</span><span id=\"__span-1-15\"><a id=\"__codelineno-1-15\" name=\"__codelineno-1-15\" href=\"#__codelineno-1-15\"></a><span class=\"w\">  </span><span class=\"n\">mediaType</span><span class=\"p\">:</span><span class=\"w\"> </span><span class=\"p\">.</span><span class=\"n\">video</span><span class=\"p\">,</span>\n</span><span id=\"__span-1-16\"><a id=\"__codelineno-1-16\" name=\"__codelineno-1-16\" href=\"#__codelineno-1-16\"></a><span class=\"w\">  </span><span class=\"n\">position</span><span class=\"p\">:</span><span class=\"w\"> </span><span class=\"p\">.</span><span class=\"n\">unspecified</span><span class=\"p\">)</span>\n</span><span id=\"__span-1-17\"><a id=\"__codelineno-1-17\" name=\"__codelineno-1-17\" href=\"#__codelineno-1-17\"></a>\n</span><span id=\"__span-1-18\"><a id=\"__codelineno-1-18\" name=\"__codelineno-1-18\" href=\"#__codelineno-1-18\"></a><span class=\"k\">for</span><span class=\"w\"> </span><span class=\"n\">d</span><span class=\"w\"> </span><span class=\"k\">in</span><span class=\"w\"> </span><span class=\"n\">session</span><span class=\"p\">.</span><span class=\"n\">devices</span><span class=\"w\"> </span><span class=\"p\">{</span>\n</span><span id=\"__span-1-19\"><a id=\"__codelineno-1-19\" name=\"__codelineno-1-19\" href=\"#__codelineno-1-19\"></a><span class=\"w\">  </span><span class=\"bp\">print</span><span class=\"p\">(</span><span class=\"s\">\"DEVICE </span><span class=\"si\">\\(</span><span class=\"n\">d</span><span class=\"p\">.</span><span class=\"n\">localizedName</span><span class=\"si\">)</span><span class=\"s\"> [</span><span class=\"si\">\\(</span><span class=\"n\">d</span><span class=\"p\">.</span><span class=\"n\">uniqueID</span><span class=\"si\">)</span><span class=\"s\">]\"</span><span class=\"p\">)</span>\n</span><span id=\"__span-1-20\"><a id=\"__codelineno-1-20\" name=\"__codelineno-1-20\" href=\"#__codelineno-1-20\"></a><span class=\"w\">  </span><span class=\"bp\">print</span><span class=\"p\">(</span><span class=\"s\">\"  model=</span><span class=\"si\">\\(</span><span class=\"n\">d</span><span class=\"p\">.</span><span class=\"n\">modelID</span><span class=\"si\">)</span><span class=\"s\">  manufacturer=</span><span class=\"si\">\\(</span><span class=\"n\">d</span><span class=\"p\">.</span><span class=\"n\">manufacturer</span><span class=\"si\">)</span><span class=\"s\">\"</span><span class=\"p\">)</span>\n</span><span id=\"__span-1-21\"><a id=\"__codelineno-1-21\" name=\"__codelineno-1-21\" href=\"#__codelineno-1-21\"></a>\n</span><span id=\"__span-1-22\"><a id=\"__codelineno-1-22\" name=\"__codelineno-1-22\" href=\"#__codelineno-1-22\"></a><span class=\"w\">  </span><span class=\"k\">for</span><span class=\"w\"> </span><span class=\"n\">f</span><span class=\"w\"> </span><span class=\"k\">in</span><span class=\"w\"> </span><span class=\"n\">d</span><span class=\"p\">.</span><span class=\"n\">formats</span><span class=\"w\"> </span><span class=\"p\">{</span>\n</span><span id=\"__span-1-23\"><a id=\"__codelineno-1-23\" name=\"__codelineno-1-23\" href=\"#__codelineno-1-23\"></a><span class=\"w\">    </span><span class=\"kd\">let</span><span class=\"w\"> </span><span class=\"nv\">dim</span><span class=\"w\"> </span><span class=\"p\">=</span><span class=\"w\"> </span><span class=\"n\">CMVideoFormatDescriptionGetDimensions</span><span class=\"p\">(</span><span class=\"n\">f</span><span class=\"p\">.</span><span class=\"n\">formatDescription</span><span class=\"p\">)</span>\n</span><span id=\"__span-1-24\"><a id=\"__codelineno-1-24\" name=\"__codelineno-1-24\" href=\"#__codelineno-1-24\"></a><span class=\"w\">    </span><span class=\"kd\">let</span><span class=\"w\"> </span><span class=\"nv\">sub</span><span class=\"w\"> </span><span class=\"p\">=</span><span class=\"w\"> </span><span class=\"n\">CMFormatDescriptionGetMediaSubType</span><span class=\"p\">(</span><span class=\"n\">f</span><span class=\"p\">.</span><span class=\"n\">formatDescription</span><span class=\"p\">)</span>\n</span><span id=\"__span-1-25\"><a id=\"__codelineno-1-25\" name=\"__codelineno-1-25\" href=\"#__codelineno-1-25\"></a>\n</span><span id=\"__span-1-26\"><a id=\"__codelineno-1-26\" name=\"__codelineno-1-26\" href=\"#__codelineno-1-26\"></a><span class=\"w\">    </span><span class=\"kd\">var</span><span class=\"w\"> </span><span class=\"nv\">line</span><span class=\"w\"> </span><span class=\"p\">=</span><span class=\"w\"> </span><span class=\"s\">\"  </span><span class=\"si\">\\(</span><span class=\"n\">dim</span><span class=\"p\">.</span><span class=\"n\">width</span><span class=\"si\">)</span><span class=\"s\">x</span><span class=\"si\">\\(</span><span class=\"n\">dim</span><span class=\"p\">.</span><span class=\"n\">height</span><span class=\"si\">)</span><span class=\"s\">  </span><span class=\"si\">\\(</span><span class=\"n\">fourcc</span><span class=\"si\">(</span><span class=\"n\">sub</span><span class=\"si\">))</span><span class=\"s\">\"</span>\n</span><span id=\"__span-1-27\"><a id=\"__codelineno-1-27\" name=\"__codelineno-1-27\" href=\"#__codelineno-1-27\"></a><span class=\"w\">    </span><span class=\"k\">for</span><span class=\"w\"> </span><span class=\"n\">r</span><span class=\"w\"> </span><span class=\"k\">in</span><span class=\"w\"> </span><span class=\"n\">f</span><span class=\"p\">.</span><span class=\"n\">videoSupportedFrameRateRanges</span><span class=\"w\"> </span><span class=\"p\">{</span>\n</span><span id=\"__span-1-28\"><a id=\"__codelineno-1-28\" name=\"__codelineno-1-28\" href=\"#__codelineno-1-28\"></a><span class=\"w\">      </span><span class=\"n\">line</span><span class=\"w\"> </span><span class=\"o\">+=</span><span class=\"w\"> </span><span class=\"nb\">String</span><span class=\"p\">(</span>\n</span><span id=\"__span-1-29\"><a id=\"__codelineno-1-29\" name=\"__codelineno-1-29\" href=\"#__codelineno-1-29\"></a><span class=\"w\">        </span><span class=\"n\">format</span><span class=\"p\">:</span><span class=\"w\"> </span><span class=\"s\">\"  fps=%.1f..%.1f  dur=%.0f..%.0fus\"</span><span class=\"p\">,</span>\n</span><span id=\"__span-1-30\"><a id=\"__codelineno-1-30\" name=\"__codelineno-1-30\" href=\"#__codelineno-1-30\"></a><span class=\"w\">        </span><span class=\"n\">r</span><span class=\"p\">.</span><span class=\"n\">minFrameRate</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"n\">r</span><span class=\"p\">.</span><span class=\"n\">maxFrameRate</span><span class=\"p\">,</span>\n</span><span id=\"__span-1-31\"><a id=\"__codelineno-1-31\" name=\"__codelineno-1-31\" href=\"#__codelineno-1-31\"></a><span class=\"w\">        </span><span class=\"n\">CMTimeGetSeconds</span><span class=\"p\">(</span><span class=\"n\">r</span><span class=\"p\">.</span><span class=\"n\">minFrameDuration</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"mf\">1e6</span><span class=\"p\">,</span>\n</span><span id=\"__span-1-32\"><a id=\"__codelineno-1-32\" name=\"__codelineno-1-32\" href=\"#__codelineno-1-32\"></a><span class=\"w\">        </span><span class=\"n\">CMTimeGetSeconds</span><span class=\"p\">(</span><span class=\"n\">r</span><span class=\"p\">.</span><span class=\"n\">maxFrameDuration</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"mf\">1e6</span><span class=\"p\">)</span>\n</span><span id=\"__span-1-33\"><a id=\"__codelineno-1-33\" name=\"__codelineno-1-33\" href=\"#__codelineno-1-33\"></a><span class=\"w\">    </span><span class=\"p\">}</span>\n</span><span id=\"__span-1-34\"><a id=\"__codelineno-1-34\" name=\"__codelineno-1-34\" href=\"#__codelineno-1-34\"></a><span class=\"w\">    </span><span class=\"bp\">print</span><span class=\"p\">(</span><span class=\"n\">line</span><span class=\"p\">)</span>\n</span><span id=\"__span-1-35\"><a id=\"__codelineno-1-35\" name=\"__codelineno-1-35\" href=\"#__codelineno-1-35\"></a>\n</span><span id=\"__span-1-36\"><a id=\"__codelineno-1-36\" name=\"__codelineno-1-36\" href=\"#__codelineno-1-36\"></a><span class=\"w\">    </span><span class=\"k\">if</span><span class=\"w\"> </span><span class=\"kd\">let</span><span class=\"w\"> </span><span class=\"nv\">ext</span><span class=\"w\"> </span><span class=\"p\">=</span><span class=\"w\"> </span><span class=\"n\">CMFormatDescriptionGetExtensions</span><span class=\"p\">(</span><span class=\"n\">f</span><span class=\"p\">.</span><span class=\"n\">formatDescription</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"k\">as</span><span class=\"p\">?</span><span class=\"w\"> </span><span class=\"p\">[</span><span class=\"nb\">String</span><span class=\"p\">:</span><span class=\"w\"> </span><span class=\"nb\">Any</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"p\">{</span>\n</span><span id=\"__span-1-37\"><a id=\"__codelineno-1-37\" name=\"__codelineno-1-37\" href=\"#__codelineno-1-37\"></a><span class=\"w\">      </span><span class=\"k\">for</span><span class=\"w\"> </span><span class=\"n\">k</span><span class=\"w\"> </span><span class=\"k\">in</span><span class=\"w\"> </span><span class=\"n\">ext</span><span class=\"p\">.</span><span class=\"n\">keys</span><span class=\"p\">.</span><span class=\"bp\">sorted</span><span class=\"p\">()</span><span class=\"w\"> </span><span class=\"p\">{</span>\n</span><span id=\"__span-1-38\"><a id=\"__codelineno-1-38\" name=\"__codelineno-1-38\" href=\"#__codelineno-1-38\"></a><span class=\"w\">        </span><span class=\"kd\">var</span><span class=\"w\"> </span><span class=\"nv\">v</span><span class=\"w\"> </span><span class=\"p\">=</span><span class=\"w\"> </span><span class=\"s\">\"</span><span class=\"si\">\\(</span><span class=\"n\">ext</span><span class=\"p\">[</span><span class=\"n\">k</span><span class=\"p\">]</span><span class=\"o\">!</span><span class=\"si\">)</span><span class=\"s\">\"</span>\n</span><span id=\"__span-1-39\"><a id=\"__codelineno-1-39\" name=\"__codelineno-1-39\" href=\"#__codelineno-1-39\"></a><span class=\"w\">        </span><span class=\"c1\">// decode fourcc-valued extensions such as</span>\n</span><span id=\"__span-1-40\"><a id=\"__codelineno-1-40\" name=\"__codelineno-1-40\" href=\"#__codelineno-1-40\"></a><span class=\"w\">        </span><span class=\"c1\">//   com.apple.cmio.format_extension.decompressed_from_format_type</span>\n</span><span id=\"__span-1-41\"><a id=\"__codelineno-1-41\" name=\"__codelineno-1-41\" href=\"#__codelineno-1-41\"></a><span class=\"w\">        </span><span class=\"k\">if</span><span class=\"w\"> </span><span class=\"n\">k</span><span class=\"p\">.</span><span class=\"bp\">contains</span><span class=\"p\">(</span><span class=\"s\">\"format_type\"</span><span class=\"p\">),</span><span class=\"w\"> </span><span class=\"kd\">let</span><span class=\"w\"> </span><span class=\"nv\">n</span><span class=\"w\"> </span><span class=\"p\">=</span><span class=\"w\"> </span><span class=\"n\">ext</span><span class=\"p\">[</span><span class=\"n\">k</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"k\">as</span><span class=\"p\">?</span><span class=\"w\"> </span><span class=\"bp\">NSNumber</span><span class=\"w\"> </span><span class=\"p\">{</span>\n</span><span id=\"__span-1-42\"><a id=\"__codelineno-1-42\" name=\"__codelineno-1-42\" href=\"#__codelineno-1-42\"></a><span class=\"w\">          </span><span class=\"n\">v</span><span class=\"w\"> </span><span class=\"p\">=</span><span class=\"w\"> </span><span class=\"s\">\"</span><span class=\"si\">\\(</span><span class=\"n\">n</span><span class=\"p\">.</span><span class=\"n\">uint32Value</span><span class=\"si\">)</span><span class=\"s\"> (</span><span class=\"si\">\\(</span><span class=\"n\">fourcc</span><span class=\"si\">(</span><span class=\"n\">n</span><span class=\"p\">.</span><span class=\"n\">uint32Value</span><span class=\"si\">))</span><span class=\"s\">)\"</span>\n</span><span id=\"__span-1-43\"><a id=\"__codelineno-1-43\" name=\"__codelineno-1-43\" href=\"#__codelineno-1-43\"></a><span class=\"w\">        </span><span class=\"p\">}</span>\n</span><span id=\"__span-1-44\"><a id=\"__codelineno-1-44\" name=\"__codelineno-1-44\" href=\"#__codelineno-1-44\"></a><span class=\"w\">        </span><span class=\"bp\">print</span><span class=\"p\">(</span><span class=\"s\">\"      ext </span><span class=\"si\">\\(</span><span class=\"n\">k</span><span class=\"si\">)</span><span class=\"s\"> = </span><span class=\"si\">\\(</span><span class=\"n\">v</span><span class=\"si\">)</span><span class=\"s\">\"</span><span class=\"p\">)</span>\n</span><span id=\"__span-1-45\"><a id=\"__codelineno-1-45\" name=\"__codelineno-1-45\" href=\"#__codelineno-1-45\"></a>\n</span><span id=\"__span-1-46\"><a id=\"__codelineno-1-46\" name=\"__codelineno-1-46\" href=\"#__codelineno-1-46\"></a><span class=\"w\">      </span><span class=\"p\">}</span>\n</span><span id=\"__span-1-47\"><a id=\"__codelineno-1-47\" name=\"__codelineno-1-47\" href=\"#__codelineno-1-47\"></a><span class=\"w\">    </span><span class=\"p\">}</span>\n</span><span id=\"__span-1-48\"><a id=\"__codelineno-1-48\" name=\"__codelineno-1-48\" href=\"#__codelineno-1-48\"></a><span class=\"w\">  </span><span class=\"p\">}</span>\n</span><span id=\"__span-1-49\"><a id=\"__codelineno-1-49\" name=\"__codelineno-1-49\" href=\"#__codelineno-1-49\"></a><span class=\"p\">}</span>\n</span></code></pre></div>\n<p>猜想压缩的版本，实际的分辨率更高，经过压缩后可以通过 USB 5Gbps 正常传输；不压缩的版本，由于带宽限制，内部不是真正按照 4K@30Hz 处理的，导致画质有损耗。</p>\n<h2 id=\"颜色问题\">颜色问题</h2>\n<h3 id=\"现象\">现象</h3>\n<p>除了清晰度问题，采集卡采到的鸿蒙电脑画面颜色不对。在鸿蒙电脑上打开 <a href=\"http://www.lagom.nl/lcd-test/zhs_white.php\">Lagom 白饱和测试图</a> 或 <a href=\"https://jia.je/display-color-test.html\">显示器色彩测试</a>，采集到的 RGB 与预期对不上，大致关系如下：</p>\n<ul>\n<li>原来 15,15,15 -&gt; 显示 6,6,6</li>\n<li>原来 64,64,64 -&gt; 显示 62,62,62</li>\n<li>原来 128,128,128 -&gt; 显示 136,136,136</li>\n<li>原来 160,160,160 -&gt; 显示 173,173,173</li>\n<li>原来 200,200,200 -&gt; 显示 219,219,219</li>\n<li>原来 224,224,224 -&gt; 显示 247,247,247</li>\n<li>原来 244,244,244 -&gt; 显示 255,255,255</li>\n</ul>\n<p>用 ffmpeg 观察后发现，原来 200,200,200 的像素，到采集卡实际给出的是 204；由于这是 limited range（16-235）下的 204，转换到 full range 后就是 <code>(204 - 16) / 219 * 255 = 219</code>。若把鸿蒙电脑直接接到显示器上，显示则正常。</p>\n<p>先考虑灰色，即 RGB 三个分量都等于同一个 x 的情况。它对应的 YUV，如果不考虑 limited range、都按 full range 算，Y 分量就等于 x。经过 MS2130S 的 luma processing 后，一开始拟合出来的结果是 <code>1.1533x − 11.55</code> 再 clamp 到 [0,255]。后来深入研究发现它其实是两个阶段：先给 Y 加上 0xfc90 寄存器的值（默认 0xF5，有符号 int8，即 −11），clip 之后再乘以 0xfc91 寄存器的值再除以 128（0xfc91 寄存器默认 0x94，即乘上 148/128 = 1.15625），再 clip 一次，即 <code>clip(clip(x + fc90) · fc91 / 128)</code>。代入默认值约为 <code>1.15625x − 12.71875</code>，与基于实测数据拟合的 <code>1.1533x − 11.55</code> 非常接近。具体计算过程看本文后面的逆向。</p>\n<h3 id=\"临时解决方法\">临时解决方法</h3>\n<p>深入研究后，我找到了一些通过设置 MS2130S 寄存器来改变其行为的方法（参考 <a href=\"https://github.com/steve-m/hsdaoh/blob/master/src/libhsdaoh.c\">steve-m/hsdaoh</a>）。在 AI 的帮助下定位到了问题：只要关闭 MS2130S 自带的 luma processing（即把寄存器 0xfc8e 从原来的 0x00 改为 0x11），颜色就会恢复正常。下面这个小工具可以在 OBS 开始录制后运行，用来 toggle luma processing，从而实时看到颜色变化：</p>\n<div class=\"language-c++ highlight\"><pre><span></span><code><span id=\"__span-2-1\"><a id=\"__codelineno-2-1\" name=\"__codelineno-2-1\" href=\"#__codelineno-2-1\"></a><span class=\"cm\">/*</span>\n</span><span id=\"__span-2-2\"><a id=\"__codelineno-2-2\" name=\"__codelineno-2-2\" href=\"#__codelineno-2-2\"></a><span class=\"cm\"> * ugreen_fix_toggle - minimal hidapi-only tool for the UGREEN 95348</span>\n</span><span id=\"__span-2-3\"><a id=\"__codelineno-2-3\" name=\"__codelineno-2-3\" href=\"#__codelineno-2-3\"></a><span class=\"cm\"> *                     (MS2130S, 2b89:5348).</span>\n</span><span id=\"__span-2-4\"><a id=\"__codelineno-2-4\" name=\"__codelineno-2-4\" href=\"#__codelineno-2-4\"></a><span class=\"cm\"> *</span>\n</span><span id=\"__span-2-5\"><a id=\"__codelineno-2-5\" name=\"__codelineno-2-5\" href=\"#__codelineno-2-5\"></a><span class=\"cm\"> * Reads a video-processing register and toggles it:</span>\n</span><span id=\"__span-2-6\"><a id=\"__codelineno-2-6\" name=\"__codelineno-2-6\" href=\"#__codelineno-2-6\"></a><span class=\"cm\"> *   0x00 -&gt; 0x11   (disable the chip's luma processing / fix the 200-&gt;219 lift)</span>\n</span><span id=\"__span-2-7\"><a id=\"__codelineno-2-7\" name=\"__codelineno-2-7\" href=\"#__codelineno-2-7\"></a><span class=\"cm\"> *   0x11 -&gt; 0x00   (re-enable it / reproduce the bug)</span>\n</span><span id=\"__span-2-8\"><a id=\"__codelineno-2-8\" name=\"__codelineno-2-8\" href=\"#__codelineno-2-8\"></a><span class=\"cm\"> *</span>\n</span><span id=\"__span-2-9\"><a id=\"__codelineno-2-9\" name=\"__codelineno-2-9\" href=\"#__codelineno-2-9\"></a><span class=\"cm\"> * Default register is 0xfc8e (confirmed to be the luma-processing register).</span>\n</span><span id=\"__span-2-10\"><a id=\"__codelineno-2-10\" name=\"__codelineno-2-10\" href=\"#__codelineno-2-10\"></a><span class=\"cm\"> * Pass another address as the first argument if needed, e.g.</span>\n</span><span id=\"__span-2-11\"><a id=\"__codelineno-2-11\" name=\"__codelineno-2-11\" href=\"#__codelineno-2-11\"></a><span class=\"cm\"> *   ./ugreen_fix_toggle 0xfc80</span>\n</span><span id=\"__span-2-12\"><a id=\"__codelineno-2-12\" name=\"__codelineno-2-12\" href=\"#__codelineno-2-12\"></a><span class=\"cm\"> *</span>\n</span><span id=\"__span-2-13\"><a id=\"__codelineno-2-13\" name=\"__codelineno-2-13\" href=\"#__codelineno-2-13\"></a><span class=\"cm\"> * build (macOS/homebrew, hidapi only):</span>\n</span><span id=\"__span-2-14\"><a id=\"__codelineno-2-14\" name=\"__codelineno-2-14\" href=\"#__codelineno-2-14\"></a><span class=\"cm\"> *   cc -O2 -I/opt/homebrew/include/hidapi ugreen_fix_toggle.c \\</span>\n</span><span id=\"__span-2-15\"><a id=\"__codelineno-2-15\" name=\"__codelineno-2-15\" href=\"#__codelineno-2-15\"></a><span class=\"cm\"> *      -L/opt/homebrew/lib -lhidapi -o ugreen_fix_toggle</span>\n</span><span id=\"__span-2-16\"><a id=\"__codelineno-2-16\" name=\"__codelineno-2-16\" href=\"#__codelineno-2-16\"></a><span class=\"cm\"> */</span>\n</span><span id=\"__span-2-17\"><a id=\"__codelineno-2-17\" name=\"__codelineno-2-17\" href=\"#__codelineno-2-17\"></a><span class=\"cp\">#include</span><span class=\"w\"> </span><span class=\"cpf\">&lt;hidapi.h&gt;</span>\n</span><span id=\"__span-2-18\"><a id=\"__codelineno-2-18\" name=\"__codelineno-2-18\" href=\"#__codelineno-2-18\"></a><span class=\"cp\">#include</span><span class=\"w\"> </span><span class=\"cpf\">&lt;stdint.h&gt;</span>\n</span><span id=\"__span-2-19\"><a id=\"__codelineno-2-19\" name=\"__codelineno-2-19\" href=\"#__codelineno-2-19\"></a><span class=\"cp\">#include</span><span class=\"w\"> </span><span class=\"cpf\">&lt;stdio.h&gt;</span>\n</span><span id=\"__span-2-20\"><a id=\"__codelineno-2-20\" name=\"__codelineno-2-20\" href=\"#__codelineno-2-20\"></a><span class=\"cp\">#include</span><span class=\"w\"> </span><span class=\"cpf\">&lt;stdlib.h&gt;</span>\n</span><span id=\"__span-2-21\"><a id=\"__codelineno-2-21\" name=\"__codelineno-2-21\" href=\"#__codelineno-2-21\"></a><span class=\"cp\">#include</span><span class=\"w\"> </span><span class=\"cpf\">&lt;string.h&gt;</span>\n</span><span id=\"__span-2-22\"><a id=\"__codelineno-2-22\" name=\"__codelineno-2-22\" href=\"#__codelineno-2-22\"></a>\n</span><span id=\"__span-2-23\"><a id=\"__codelineno-2-23\" name=\"__codelineno-2-23\" href=\"#__codelineno-2-23\"></a><span class=\"cp\">#define VID 0x2b89</span>\n</span><span id=\"__span-2-24\"><a id=\"__codelineno-2-24\" name=\"__codelineno-2-24\" href=\"#__codelineno-2-24\"></a><span class=\"cp\">#define PID 0x5348</span>\n</span><span id=\"__span-2-25\"><a id=\"__codelineno-2-25\" name=\"__codelineno-2-25\" href=\"#__codelineno-2-25\"></a><span class=\"cp\">#define DEFAULT_REG 0xfc8e</span>\n</span><span id=\"__span-2-26\"><a id=\"__codelineno-2-26\" name=\"__codelineno-2-26\" href=\"#__codelineno-2-26\"></a>\n</span><span id=\"__span-2-27\"><a id=\"__codelineno-2-27\" name=\"__codelineno-2-27\" href=\"#__codelineno-2-27\"></a><span class=\"k\">static</span><span class=\"w\"> </span><span class=\"n\">hid_device</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"n\">h</span><span class=\"p\">;</span>\n</span><span id=\"__span-2-28\"><a id=\"__codelineno-2-28\" name=\"__codelineno-2-28\" href=\"#__codelineno-2-28\"></a>\n</span><span id=\"__span-2-29\"><a id=\"__codelineno-2-29\" name=\"__codelineno-2-29\" href=\"#__codelineno-2-29\"></a><span class=\"cm\">/* MS2130S vendor HID feature report:</span>\n</span><span id=\"__span-2-30\"><a id=\"__codelineno-2-30\" name=\"__codelineno-2-30\" href=\"#__codelineno-2-30\"></a><span class=\"cm\"> *   [0x01, 0xb6, addrH, addrL, val, 0, 0, 0, 0]  write</span>\n</span><span id=\"__span-2-31\"><a id=\"__codelineno-2-31\" name=\"__codelineno-2-31\" href=\"#__codelineno-2-31\"></a><span class=\"cm\"> *   [0x01, 0xb5, addrH, addrL, 0, 0, 0, 0, 0]    read request</span>\n</span><span id=\"__span-2-32\"><a id=\"__codelineno-2-32\" name=\"__codelineno-2-32\" href=\"#__codelineno-2-32\"></a><span class=\"cm\"> * GET_REPORT returns 64 bytes; the value is byte 4. */</span>\n</span><span id=\"__span-2-33\"><a id=\"__codelineno-2-33\" name=\"__codelineno-2-33\" href=\"#__codelineno-2-33\"></a><span class=\"k\">static</span><span class=\"w\"> </span><span class=\"kt\">int</span><span class=\"w\"> </span><span class=\"nf\">reg_write</span><span class=\"p\">(</span><span class=\"kt\">uint16_t</span><span class=\"w\"> </span><span class=\"n\">addr</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"kt\">uint8_t</span><span class=\"w\"> </span><span class=\"n\">val</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"p\">{</span>\n</span><span id=\"__span-2-34\"><a id=\"__codelineno-2-34\" name=\"__codelineno-2-34\" href=\"#__codelineno-2-34\"></a><span class=\"w\">  </span><span class=\"kt\">unsigned</span><span class=\"w\"> </span><span class=\"kt\">char</span><span class=\"w\"> </span><span class=\"n\">buf</span><span class=\"p\">[</span><span class=\"mi\">9</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span><span class=\"p\">{</span><span class=\"mh\">0x01</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"mh\">0xb6</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"n\">addr</span><span class=\"w\"> </span><span class=\"o\">&gt;&gt;</span><span class=\"w\"> </span><span class=\"mi\">8</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"n\">addr</span><span class=\"w\"> </span><span class=\"o\">&amp;</span><span class=\"w\"> </span><span class=\"mh\">0xff</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"n\">val</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"mi\">0</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"mi\">0</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"mi\">0</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"mi\">0</span><span class=\"p\">};</span>\n</span><span id=\"__span-2-35\"><a id=\"__codelineno-2-35\" name=\"__codelineno-2-35\" href=\"#__codelineno-2-35\"></a><span class=\"w\">  </span><span class=\"k\">return</span><span class=\"w\"> </span><span class=\"n\">hid_send_feature_report</span><span class=\"p\">(</span><span class=\"n\">h</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"n\">buf</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"k\">sizeof</span><span class=\"p\">(</span><span class=\"n\">buf</span><span class=\"p\">));</span>\n</span><span id=\"__span-2-36\"><a id=\"__codelineno-2-36\" name=\"__codelineno-2-36\" href=\"#__codelineno-2-36\"></a><span class=\"p\">}</span>\n</span><span id=\"__span-2-37\"><a id=\"__codelineno-2-37\" name=\"__codelineno-2-37\" href=\"#__codelineno-2-37\"></a>\n</span><span id=\"__span-2-38\"><a id=\"__codelineno-2-38\" name=\"__codelineno-2-38\" href=\"#__codelineno-2-38\"></a><span class=\"k\">static</span><span class=\"w\"> </span><span class=\"kt\">int</span><span class=\"w\"> </span><span class=\"nf\">reg_read</span><span class=\"p\">(</span><span class=\"kt\">uint16_t</span><span class=\"w\"> </span><span class=\"n\">addr</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"kt\">uint8_t</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"n\">val</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"p\">{</span>\n</span><span id=\"__span-2-39\"><a id=\"__codelineno-2-39\" name=\"__codelineno-2-39\" href=\"#__codelineno-2-39\"></a><span class=\"w\">  </span><span class=\"kt\">unsigned</span><span class=\"w\"> </span><span class=\"kt\">char</span><span class=\"w\"> </span><span class=\"n\">cmd</span><span class=\"p\">[</span><span class=\"mi\">9</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span><span class=\"p\">{</span><span class=\"mh\">0x01</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"mh\">0xb5</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"n\">addr</span><span class=\"w\"> </span><span class=\"o\">&gt;&gt;</span><span class=\"w\"> </span><span class=\"mi\">8</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"n\">addr</span><span class=\"w\"> </span><span class=\"o\">&amp;</span><span class=\"w\"> </span><span class=\"mh\">0xff</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"mi\">0</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"mi\">0</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"mi\">0</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"mi\">0</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"mi\">0</span><span class=\"p\">};</span>\n</span><span id=\"__span-2-40\"><a id=\"__codelineno-2-40\" name=\"__codelineno-2-40\" href=\"#__codelineno-2-40\"></a><span class=\"w\">  </span><span class=\"kt\">unsigned</span><span class=\"w\"> </span><span class=\"kt\">char</span><span class=\"w\"> </span><span class=\"n\">rsp</span><span class=\"p\">[</span><span class=\"mi\">64</span><span class=\"p\">];</span>\n</span><span id=\"__span-2-41\"><a id=\"__codelineno-2-41\" name=\"__codelineno-2-41\" href=\"#__codelineno-2-41\"></a>\n</span><span id=\"__span-2-42\"><a id=\"__codelineno-2-42\" name=\"__codelineno-2-42\" href=\"#__codelineno-2-42\"></a><span class=\"w\">  </span><span class=\"k\">if</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">hid_send_feature_report</span><span class=\"p\">(</span><span class=\"n\">h</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"n\">cmd</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"k\">sizeof</span><span class=\"p\">(</span><span class=\"n\">cmd</span><span class=\"p\">))</span><span class=\"w\"> </span><span class=\"o\">&lt;</span><span class=\"w\"> </span><span class=\"mi\">0</span><span class=\"p\">)</span>\n</span><span id=\"__span-2-43\"><a id=\"__codelineno-2-43\" name=\"__codelineno-2-43\" href=\"#__codelineno-2-43\"></a><span class=\"w\">    </span><span class=\"k\">return</span><span class=\"w\"> </span><span class=\"mi\">-1</span><span class=\"p\">;</span>\n</span><span id=\"__span-2-44\"><a id=\"__codelineno-2-44\" name=\"__codelineno-2-44\" href=\"#__codelineno-2-44\"></a><span class=\"w\">  </span><span class=\"n\">memset</span><span class=\"p\">(</span><span class=\"n\">rsp</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"mi\">0</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"k\">sizeof</span><span class=\"p\">(</span><span class=\"n\">rsp</span><span class=\"p\">));</span>\n</span><span id=\"__span-2-45\"><a id=\"__codelineno-2-45\" name=\"__codelineno-2-45\" href=\"#__codelineno-2-45\"></a><span class=\"w\">  </span><span class=\"n\">rsp</span><span class=\"p\">[</span><span class=\"mi\">0</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span><span class=\"mh\">0x01</span><span class=\"p\">;</span>\n</span><span id=\"__span-2-46\"><a id=\"__codelineno-2-46\" name=\"__codelineno-2-46\" href=\"#__codelineno-2-46\"></a><span class=\"w\">  </span><span class=\"k\">if</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">hid_get_feature_report</span><span class=\"p\">(</span><span class=\"n\">h</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"n\">rsp</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"k\">sizeof</span><span class=\"p\">(</span><span class=\"n\">rsp</span><span class=\"p\">))</span><span class=\"w\"> </span><span class=\"o\">&lt;</span><span class=\"w\"> </span><span class=\"mi\">0</span><span class=\"p\">)</span>\n</span><span id=\"__span-2-47\"><a id=\"__codelineno-2-47\" name=\"__codelineno-2-47\" href=\"#__codelineno-2-47\"></a><span class=\"w\">    </span><span class=\"k\">return</span><span class=\"w\"> </span><span class=\"mi\">-1</span><span class=\"p\">;</span>\n</span><span id=\"__span-2-48\"><a id=\"__codelineno-2-48\" name=\"__codelineno-2-48\" href=\"#__codelineno-2-48\"></a><span class=\"w\">  </span><span class=\"o\">*</span><span class=\"n\">val</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span><span class=\"n\">rsp</span><span class=\"p\">[</span><span class=\"mi\">4</span><span class=\"p\">];</span>\n</span><span id=\"__span-2-49\"><a id=\"__codelineno-2-49\" name=\"__codelineno-2-49\" href=\"#__codelineno-2-49\"></a><span class=\"w\">  </span><span class=\"k\">return</span><span class=\"w\"> </span><span class=\"mi\">0</span><span class=\"p\">;</span>\n</span><span id=\"__span-2-50\"><a id=\"__codelineno-2-50\" name=\"__codelineno-2-50\" href=\"#__codelineno-2-50\"></a><span class=\"p\">}</span>\n</span><span id=\"__span-2-51\"><a id=\"__codelineno-2-51\" name=\"__codelineno-2-51\" href=\"#__codelineno-2-51\"></a>\n</span><span id=\"__span-2-52\"><a id=\"__codelineno-2-52\" name=\"__codelineno-2-52\" href=\"#__codelineno-2-52\"></a><span class=\"kt\">int</span><span class=\"w\"> </span><span class=\"nf\">main</span><span class=\"p\">(</span><span class=\"kt\">int</span><span class=\"w\"> </span><span class=\"n\">argc</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"kt\">char</span><span class=\"w\"> </span><span class=\"o\">**</span><span class=\"n\">argv</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"p\">{</span>\n</span><span id=\"__span-2-53\"><a id=\"__codelineno-2-53\" name=\"__codelineno-2-53\" href=\"#__codelineno-2-53\"></a><span class=\"w\">  </span><span class=\"kt\">uint16_t</span><span class=\"w\"> </span><span class=\"n\">addr</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span><span class=\"n\">DEFAULT_REG</span><span class=\"p\">;</span>\n</span><span id=\"__span-2-54\"><a id=\"__codelineno-2-54\" name=\"__codelineno-2-54\" href=\"#__codelineno-2-54\"></a><span class=\"w\">  </span><span class=\"kt\">uint8_t</span><span class=\"w\"> </span><span class=\"n\">cur</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"n\">next</span><span class=\"p\">;</span>\n</span><span id=\"__span-2-55\"><a id=\"__codelineno-2-55\" name=\"__codelineno-2-55\" href=\"#__codelineno-2-55\"></a>\n</span><span id=\"__span-2-56\"><a id=\"__codelineno-2-56\" name=\"__codelineno-2-56\" href=\"#__codelineno-2-56\"></a><span class=\"w\">  </span><span class=\"k\">if</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">argc</span><span class=\"w\"> </span><span class=\"o\">&gt;</span><span class=\"w\"> </span><span class=\"mi\">1</span><span class=\"p\">)</span>\n</span><span id=\"__span-2-57\"><a id=\"__codelineno-2-57\" name=\"__codelineno-2-57\" href=\"#__codelineno-2-57\"></a><span class=\"w\">    </span><span class=\"n\">addr</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"kt\">uint16_t</span><span class=\"p\">)</span><span class=\"n\">strtoul</span><span class=\"p\">(</span><span class=\"n\">argv</span><span class=\"p\">[</span><span class=\"mi\">1</span><span class=\"p\">],</span><span class=\"w\"> </span><span class=\"nb\">NULL</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"mi\">0</span><span class=\"p\">);</span>\n</span><span id=\"__span-2-58\"><a id=\"__codelineno-2-58\" name=\"__codelineno-2-58\" href=\"#__codelineno-2-58\"></a>\n</span><span id=\"__span-2-59\"><a id=\"__codelineno-2-59\" name=\"__codelineno-2-59\" href=\"#__codelineno-2-59\"></a><span class=\"w\">  </span><span class=\"k\">if</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">hid_init</span><span class=\"p\">()</span><span class=\"w\"> </span><span class=\"o\">&lt;</span><span class=\"w\"> </span><span class=\"mi\">0</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"p\">{</span>\n</span><span id=\"__span-2-60\"><a id=\"__codelineno-2-60\" name=\"__codelineno-2-60\" href=\"#__codelineno-2-60\"></a><span class=\"w\">    </span><span class=\"n\">fprintf</span><span class=\"p\">(</span><span class=\"n\">stderr</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"s\">\"hid_init failed</span><span class=\"se\">\\n</span><span class=\"s\">\"</span><span class=\"p\">);</span>\n</span><span id=\"__span-2-61\"><a id=\"__codelineno-2-61\" name=\"__codelineno-2-61\" href=\"#__codelineno-2-61\"></a><span class=\"w\">    </span><span class=\"k\">return</span><span class=\"w\"> </span><span class=\"mi\">1</span><span class=\"p\">;</span>\n</span><span id=\"__span-2-62\"><a id=\"__codelineno-2-62\" name=\"__codelineno-2-62\" href=\"#__codelineno-2-62\"></a><span class=\"w\">  </span><span class=\"p\">}</span>\n</span><span id=\"__span-2-63\"><a id=\"__codelineno-2-63\" name=\"__codelineno-2-63\" href=\"#__codelineno-2-63\"></a><span class=\"w\">  </span><span class=\"n\">h</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span><span class=\"n\">hid_open</span><span class=\"p\">(</span><span class=\"n\">VID</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"n\">PID</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nb\">NULL</span><span class=\"p\">);</span>\n</span><span id=\"__span-2-64\"><a id=\"__codelineno-2-64\" name=\"__codelineno-2-64\" href=\"#__codelineno-2-64\"></a><span class=\"w\">  </span><span class=\"k\">if</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"o\">!</span><span class=\"n\">h</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"p\">{</span>\n</span><span id=\"__span-2-65\"><a id=\"__codelineno-2-65\" name=\"__codelineno-2-65\" href=\"#__codelineno-2-65\"></a><span class=\"w\">    </span><span class=\"n\">fprintf</span><span class=\"p\">(</span><span class=\"n\">stderr</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"s\">\"UGREEN %04x:%04x not found (is it plugged in?)</span><span class=\"se\">\\n</span><span class=\"s\">\"</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"n\">VID</span><span class=\"p\">,</span>\n</span><span id=\"__span-2-66\"><a id=\"__codelineno-2-66\" name=\"__codelineno-2-66\" href=\"#__codelineno-2-66\"></a><span class=\"w\">            </span><span class=\"n\">PID</span><span class=\"p\">);</span>\n</span><span id=\"__span-2-67\"><a id=\"__codelineno-2-67\" name=\"__codelineno-2-67\" href=\"#__codelineno-2-67\"></a><span class=\"w\">    </span><span class=\"k\">return</span><span class=\"w\"> </span><span class=\"mi\">1</span><span class=\"p\">;</span>\n</span><span id=\"__span-2-68\"><a id=\"__codelineno-2-68\" name=\"__codelineno-2-68\" href=\"#__codelineno-2-68\"></a><span class=\"w\">  </span><span class=\"p\">}</span>\n</span><span id=\"__span-2-69\"><a id=\"__codelineno-2-69\" name=\"__codelineno-2-69\" href=\"#__codelineno-2-69\"></a>\n</span><span id=\"__span-2-70\"><a id=\"__codelineno-2-70\" name=\"__codelineno-2-70\" href=\"#__codelineno-2-70\"></a><span class=\"w\">  </span><span class=\"k\">if</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">reg_read</span><span class=\"p\">(</span><span class=\"n\">addr</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"o\">&amp;</span><span class=\"n\">cur</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">&lt;</span><span class=\"w\"> </span><span class=\"mi\">0</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"p\">{</span>\n</span><span id=\"__span-2-71\"><a id=\"__codelineno-2-71\" name=\"__codelineno-2-71\" href=\"#__codelineno-2-71\"></a><span class=\"w\">    </span><span class=\"n\">fprintf</span><span class=\"p\">(</span><span class=\"n\">stderr</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"s\">\"register read failed: %ls</span><span class=\"se\">\\n</span><span class=\"s\">\"</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"n\">hid_error</span><span class=\"p\">(</span><span class=\"n\">h</span><span class=\"p\">));</span>\n</span><span id=\"__span-2-72\"><a id=\"__codelineno-2-72\" name=\"__codelineno-2-72\" href=\"#__codelineno-2-72\"></a><span class=\"w\">    </span><span class=\"n\">hid_close</span><span class=\"p\">(</span><span class=\"n\">h</span><span class=\"p\">);</span>\n</span><span id=\"__span-2-73\"><a id=\"__codelineno-2-73\" name=\"__codelineno-2-73\" href=\"#__codelineno-2-73\"></a><span class=\"w\">    </span><span class=\"k\">return</span><span class=\"w\"> </span><span class=\"mi\">1</span><span class=\"p\">;</span>\n</span><span id=\"__span-2-74\"><a id=\"__codelineno-2-74\" name=\"__codelineno-2-74\" href=\"#__codelineno-2-74\"></a><span class=\"w\">  </span><span class=\"p\">}</span>\n</span><span id=\"__span-2-75\"><a id=\"__codelineno-2-75\" name=\"__codelineno-2-75\" href=\"#__codelineno-2-75\"></a>\n</span><span id=\"__span-2-76\"><a id=\"__codelineno-2-76\" name=\"__codelineno-2-76\" href=\"#__codelineno-2-76\"></a><span class=\"w\">  </span><span class=\"k\">if</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">cur</span><span class=\"w\"> </span><span class=\"o\">==</span><span class=\"w\"> </span><span class=\"mh\">0x00</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"p\">{</span>\n</span><span id=\"__span-2-77\"><a id=\"__codelineno-2-77\" name=\"__codelineno-2-77\" href=\"#__codelineno-2-77\"></a><span class=\"w\">    </span><span class=\"n\">next</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span><span class=\"mh\">0x11</span><span class=\"p\">;</span>\n</span><span id=\"__span-2-78\"><a id=\"__codelineno-2-78\" name=\"__codelineno-2-78\" href=\"#__codelineno-2-78\"></a><span class=\"w\">  </span><span class=\"p\">}</span><span class=\"w\"> </span><span class=\"k\">else</span><span class=\"w\"> </span><span class=\"k\">if</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">cur</span><span class=\"w\"> </span><span class=\"o\">==</span><span class=\"w\"> </span><span class=\"mh\">0x11</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"p\">{</span>\n</span><span id=\"__span-2-79\"><a id=\"__codelineno-2-79\" name=\"__codelineno-2-79\" href=\"#__codelineno-2-79\"></a><span class=\"w\">    </span><span class=\"n\">next</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span><span class=\"mh\">0x00</span><span class=\"p\">;</span>\n</span><span id=\"__span-2-80\"><a id=\"__codelineno-2-80\" name=\"__codelineno-2-80\" href=\"#__codelineno-2-80\"></a><span class=\"w\">  </span><span class=\"p\">}</span><span class=\"w\"> </span><span class=\"k\">else</span><span class=\"w\"> </span><span class=\"p\">{</span>\n</span><span id=\"__span-2-81\"><a id=\"__codelineno-2-81\" name=\"__codelineno-2-81\" href=\"#__codelineno-2-81\"></a><span class=\"w\">    </span><span class=\"n\">fprintf</span><span class=\"p\">(</span><span class=\"n\">stderr</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"s\">\"%04x = 0x%02x (unexpected, not touching)</span><span class=\"se\">\\n</span><span class=\"s\">\"</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"n\">addr</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"n\">cur</span><span class=\"p\">);</span>\n</span><span id=\"__span-2-82\"><a id=\"__codelineno-2-82\" name=\"__codelineno-2-82\" href=\"#__codelineno-2-82\"></a><span class=\"w\">    </span><span class=\"n\">hid_close</span><span class=\"p\">(</span><span class=\"n\">h</span><span class=\"p\">);</span>\n</span><span id=\"__span-2-83\"><a id=\"__codelineno-2-83\" name=\"__codelineno-2-83\" href=\"#__codelineno-2-83\"></a><span class=\"w\">    </span><span class=\"k\">return</span><span class=\"w\"> </span><span class=\"mi\">2</span><span class=\"p\">;</span>\n</span><span id=\"__span-2-84\"><a id=\"__codelineno-2-84\" name=\"__codelineno-2-84\" href=\"#__codelineno-2-84\"></a><span class=\"w\">  </span><span class=\"p\">}</span>\n</span><span id=\"__span-2-85\"><a id=\"__codelineno-2-85\" name=\"__codelineno-2-85\" href=\"#__codelineno-2-85\"></a>\n</span><span id=\"__span-2-86\"><a id=\"__codelineno-2-86\" name=\"__codelineno-2-86\" href=\"#__codelineno-2-86\"></a><span class=\"w\">  </span><span class=\"k\">if</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">reg_write</span><span class=\"p\">(</span><span class=\"n\">addr</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"n\">next</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">&lt;</span><span class=\"w\"> </span><span class=\"mi\">0</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"p\">{</span>\n</span><span id=\"__span-2-87\"><a id=\"__codelineno-2-87\" name=\"__codelineno-2-87\" href=\"#__codelineno-2-87\"></a><span class=\"w\">    </span><span class=\"n\">fprintf</span><span class=\"p\">(</span><span class=\"n\">stderr</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"s\">\"register write failed: %ls</span><span class=\"se\">\\n</span><span class=\"s\">\"</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"n\">hid_error</span><span class=\"p\">(</span><span class=\"n\">h</span><span class=\"p\">));</span>\n</span><span id=\"__span-2-88\"><a id=\"__codelineno-2-88\" name=\"__codelineno-2-88\" href=\"#__codelineno-2-88\"></a><span class=\"w\">    </span><span class=\"n\">hid_close</span><span class=\"p\">(</span><span class=\"n\">h</span><span class=\"p\">);</span>\n</span><span id=\"__span-2-89\"><a id=\"__codelineno-2-89\" name=\"__codelineno-2-89\" href=\"#__codelineno-2-89\"></a><span class=\"w\">    </span><span class=\"k\">return</span><span class=\"w\"> </span><span class=\"mi\">1</span><span class=\"p\">;</span>\n</span><span id=\"__span-2-90\"><a id=\"__codelineno-2-90\" name=\"__codelineno-2-90\" href=\"#__codelineno-2-90\"></a><span class=\"w\">  </span><span class=\"p\">}</span>\n</span><span id=\"__span-2-91\"><a id=\"__codelineno-2-91\" name=\"__codelineno-2-91\" href=\"#__codelineno-2-91\"></a>\n</span><span id=\"__span-2-92\"><a id=\"__codelineno-2-92\" name=\"__codelineno-2-92\" href=\"#__codelineno-2-92\"></a><span class=\"w\">  </span><span class=\"n\">printf</span><span class=\"p\">(</span><span class=\"s\">\"%04x: 0x%02x -&gt; 0x%02x</span><span class=\"se\">\\n</span><span class=\"s\">\"</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"n\">addr</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"n\">cur</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"n\">next</span><span class=\"p\">);</span>\n</span><span id=\"__span-2-93\"><a id=\"__codelineno-2-93\" name=\"__codelineno-2-93\" href=\"#__codelineno-2-93\"></a><span class=\"w\">  </span><span class=\"n\">printf</span><span class=\"p\">(</span><span class=\"s\">\"(0x11 = luma processing disabled = fix on; 0x00 = default/bug)</span><span class=\"se\">\\n</span><span class=\"s\">\"</span><span class=\"p\">);</span>\n</span><span id=\"__span-2-94\"><a id=\"__codelineno-2-94\" name=\"__codelineno-2-94\" href=\"#__codelineno-2-94\"></a>\n</span><span id=\"__span-2-95\"><a id=\"__codelineno-2-95\" name=\"__codelineno-2-95\" href=\"#__codelineno-2-95\"></a><span class=\"w\">  </span><span class=\"n\">hid_close</span><span class=\"p\">(</span><span class=\"n\">h</span><span class=\"p\">);</span>\n</span><span id=\"__span-2-96\"><a id=\"__codelineno-2-96\" name=\"__codelineno-2-96\" href=\"#__codelineno-2-96\"></a><span class=\"w\">  </span><span class=\"n\">hid_exit</span><span class=\"p\">();</span>\n</span><span id=\"__span-2-97\"><a id=\"__codelineno-2-97\" name=\"__codelineno-2-97\" href=\"#__codelineno-2-97\"></a><span class=\"w\">  </span><span class=\"k\">return</span><span class=\"w\"> </span><span class=\"mi\">0</span><span class=\"p\">;</span>\n</span><span id=\"__span-2-98\"><a id=\"__codelineno-2-98\" name=\"__codelineno-2-98\" href=\"#__codelineno-2-98\"></a><span class=\"p\">}</span>\n</span></code></pre></div>\n<p>编译和运行：</p>\n<div class=\"language-shell highlight\"><pre><span></span><code><span id=\"__span-3-1\"><a id=\"__codelineno-3-1\" name=\"__codelineno-3-1\" href=\"#__codelineno-3-1\"></a>$<span class=\"w\"> </span>brew<span class=\"w\"> </span>install<span class=\"w\"> </span>hidapi\n</span><span id=\"__span-3-2\"><a id=\"__codelineno-3-2\" name=\"__codelineno-3-2\" href=\"#__codelineno-3-2\"></a>$<span class=\"w\"> </span>cc<span class=\"w\"> </span>-O2<span class=\"w\"> </span>-I/opt/homebrew/include/hidapi<span class=\"w\"> </span>ugreen_fix_toggle.c<span class=\"w\"> </span>-L/opt/homebrew/lib<span class=\"w\"> </span>-lhidapi<span class=\"w\"> </span>-o<span class=\"w\"> </span>ugreen_fix_toggle\n</span><span id=\"__span-3-3\"><a id=\"__codelineno-3-3\" name=\"__codelineno-3-3\" href=\"#__codelineno-3-3\"></a><span class=\"c1\"># 此时是有问题的状态</span>\n</span><span id=\"__span-3-4\"><a id=\"__codelineno-3-4\" name=\"__codelineno-3-4\" href=\"#__codelineno-3-4\"></a>$<span class=\"w\"> </span>./ugreen_fix_toggle\n</span><span id=\"__span-3-5\"><a id=\"__codelineno-3-5\" name=\"__codelineno-3-5\" href=\"#__codelineno-3-5\"></a>fc8e:<span class=\"w\"> </span>0x00<span class=\"w\"> </span>-&gt;<span class=\"w\"> </span>0x11\n</span><span id=\"__span-3-6\"><a id=\"__codelineno-3-6\" name=\"__codelineno-3-6\" href=\"#__codelineno-3-6\"></a><span class=\"o\">(</span><span class=\"nv\">0x11</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span>luma<span class=\"w\"> </span>processing<span class=\"w\"> </span><span class=\"nv\">disabled</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span>fix<span class=\"w\"> </span>on<span class=\"p\">;</span><span class=\"w\"> </span><span class=\"nv\">0x00</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span>default/bug<span class=\"o\">)</span>\n</span><span id=\"__span-3-7\"><a id=\"__codelineno-3-7\" name=\"__codelineno-3-7\" href=\"#__codelineno-3-7\"></a><span class=\"c1\"># toggle 以后，颜色问题修复</span>\n</span><span id=\"__span-3-8\"><a id=\"__codelineno-3-8\" name=\"__codelineno-3-8\" href=\"#__codelineno-3-8\"></a>$<span class=\"w\"> </span>./ugreen_fix_toggle\n</span><span id=\"__span-3-9\"><a id=\"__codelineno-3-9\" name=\"__codelineno-3-9\" href=\"#__codelineno-3-9\"></a>fc8e:<span class=\"w\"> </span>0x11<span class=\"w\"> </span>-&gt;<span class=\"w\"> </span>0x00\n</span><span id=\"__span-3-10\"><a id=\"__codelineno-3-10\" name=\"__codelineno-3-10\" href=\"#__codelineno-3-10\"></a><span class=\"o\">(</span><span class=\"nv\">0x11</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span>luma<span class=\"w\"> </span>processing<span class=\"w\"> </span><span class=\"nv\">disabled</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span>fix<span class=\"w\"> </span>on<span class=\"p\">;</span><span class=\"w\"> </span><span class=\"nv\">0x00</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span>default/bug<span class=\"o\">)</span>\n</span><span id=\"__span-3-11\"><a id=\"__codelineno-3-11\" name=\"__codelineno-3-11\" href=\"#__codelineno-3-11\"></a><span class=\"c1\"># 再次 toggle，颜色问题重新出现</span>\n</span></code></pre></div>\n<p>修复后：</p>\n<ul>\n<li>原来 15,15,15 -&gt; 显示 15,15,15</li>\n<li>原来 64,64,64 -&gt; 显示 63,63,63</li>\n<li>原来 128,128,128 -&gt; 显示 127,127,127</li>\n<li>原来 160,160,160 -&gt; 显示 160,160,160</li>\n<li>原来 200,200,200 -&gt; 显示 199,199,199</li>\n<li>原来 224,224,224 -&gt; 显示 224,224,224</li>\n<li>原来 244,244,244 -&gt; 显示 243,243,243</li>\n</ul>\n<p>虽然仍有很小的偏差，但可以认为问题已经解决。</p>\n<h3 id=\"永久解决方法\">永久解决方法</h3>\n<p>不过每次开始采集后都要重新跑一次这个工具，还是有点麻烦。一劳永逸的办法是参考 <a href=\"https://github.com/steve-m/ms2130_patcher/blob/master/ms2130_patch.c\">steve-m/ms2130_patcher</a>，给固件打补丁，让硬件往 0xfc8e 寄存器写入 0x11 而不是 0x00。</p>\n<p>首先用 <a href=\"https://github.com/steve-m/ms213x_flash\">steve-m/ms213x_flash</a> 导出绿联 95348 自带的固件，然后让 AI 进行逆向，这个固件就是一个 8051 代码，有很多成熟的工具。具体的补丁方法和上面类似，下面直接给出 AI 对固件代码以及如何修复的分析：</p>\n<h4 id=\"固件代码\">固件代码</h4>\n<p><code>0xfc8e</code> 有两个相关的位：bit 0（掩码 <code>0x01</code>）和 bit 4（掩码 <code>0x10</code>）。流重初始化流程 <code>FUN_CODE_c220()</code> 会通过位掩码辅助函数 <code>FUN_CODE_87c7(mask, addrH, addrL, value)</code> 把这两位都清零。要写入的值通过 <code>R3</code> 传入：非零表示置位被掩码选中的位，零表示清零。</p>\n<table>\n<thead>\n<tr>\n<th>CPU 地址（bank 1）</th>\n<th>代码</th>\n<th>作用</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>c268</code></td>\n<td><code>MOV R3,#01h ; JNB bit05,c26f ; MOV R3,#00h</code><br><code>MOV R5,#01h ; MOV R7,#8eh ; MOV R6,#fch ; LJMP 87c7h</code></td>\n<td>清除 <code>0xfc8e</code> 的 bit 0</td>\n</tr>\n<tr>\n<td><code>c27e</code></td>\n<td><code>MOV R3,#01h ; JNB bit05,c285 ; MOV R3,#00h</code><br><code>MOV R5,#10h ; MOV R7,#8eh ; MOV R6,#fch ; LJMP 87c7h</code></td>\n<td>清除 <code>0xfc8e</code> 的 bit 4</td>\n</tr>\n</tbody>\n</table>\n<p>两次调用之后 <code>0xfc8e = 0x00</code>。</p>\n<h4 id=\"具体改动\">具体改动</h4>\n<p>把两处 <code>MOV R3,#00h</code>（<code>7b 00</code>）指令改成 <code>MOV R3,#01h</code>（<code>7b 01</code>），这样每次掩码更新都会走<em>置位</em>分支，寄存器最终变成 <code>0x11</code>。</p>\n<table>\n<thead>\n<tr>\n<th style=\"text-align: right;\">文件偏移</th>\n<th style=\"text-align: right;\">原始值</th>\n<th style=\"text-align: right;\">补丁值</th>\n<th>含义</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td style=\"text-align: right;\"><code>0x1429e</code>（bank1 <code>c26e</code>）</td>\n<td style=\"text-align: right;\"><code>00</code></td>\n<td style=\"text-align: right;\"><code>01</code></td>\n<td><code>0xfc8e</code> bit 0 的取值操作数</td>\n</tr>\n<tr>\n<td style=\"text-align: right;\"><code>0x142b4</code>（bank1 <code>c284</code>）</td>\n<td style=\"text-align: right;\"><code>00</code></td>\n<td style=\"text-align: right;\"><code>01</code></td>\n<td><code>0xfc8e</code> bit 4 的取值操作数</td>\n</tr>\n<tr>\n<td style=\"text-align: right;\"><code>0x18033</code></td>\n<td style=\"text-align: right;\"><code>7c</code></td>\n<td style=\"text-align: right;\"><code>7e</code></td>\n<td>代码校验和 <code>0x797c</code> → <code>0x797e</code></td>\n</tr>\n</tbody>\n</table>\n<p>反汇编打过补丁的字节，可以看到两处立即数现在都加载 <code>0x01</code>：</p>\n<div class=\"language-console highlight\"><pre><span></span><code><span id=\"__span-4-1\"><a id=\"__codelineno-4-1\" name=\"__codelineno-4-1\" href=\"#__codelineno-4-1\"></a><span class=\"go\">c268: 7b01  MOV R3, #01h</span>\n</span><span id=\"__span-4-2\"><a id=\"__codelineno-4-2\" name=\"__codelineno-4-2\" href=\"#__codelineno-4-2\"></a><span class=\"go\">c26a: 300502 JNB bit05, c26fh</span>\n</span><span id=\"__span-4-3\"><a id=\"__codelineno-4-3\" name=\"__codelineno-4-3\" href=\"#__codelineno-4-3\"></a><span class=\"go\">c26d: 7b01  MOV R3, #01h      &lt;- 原来是 #00h</span>\n</span><span id=\"__span-4-4\"><a id=\"__codelineno-4-4\" name=\"__codelineno-4-4\" href=\"#__codelineno-4-4\"></a><span class=\"go\">c26f: 7d01  MOV R5, #01h</span>\n</span><span id=\"__span-4-5\"><a id=\"__codelineno-4-5\" name=\"__codelineno-4-5\" href=\"#__codelineno-4-5\"></a><span class=\"go\">c271: 7f8e  MOV R7, #8eh</span>\n</span><span id=\"__span-4-6\"><a id=\"__codelineno-4-6\" name=\"__codelineno-4-6\" href=\"#__codelineno-4-6\"></a><span class=\"go\">c273: 7efc  MOV R6, #fch</span>\n</span><span id=\"__span-4-7\"><a id=\"__codelineno-4-7\" name=\"__codelineno-4-7\" href=\"#__codelineno-4-7\"></a><span class=\"go\">c275: 0287c7 LJMP 87c7h</span>\n</span></code></pre></div>\n<h3 id=\"小结\">小结</h3>\n<p>核心就是把上面我通过 hidapi 从 host 端写入寄存器的操作，换成了直接在固件里写入：固件本来是 clear，改成了 set，这样就禁用了 luma processing，持久化了这个改动。</p>\n<p>这部分代码以及固件已经开源到 <a href=\"http://github.com/jiegec/ugreen-95348-patcher\">jiegec/ugreen-95348-patcher</a>，感兴趣的读者可以尝试一下，尝试之前记得备份固件，而且有变砖的风险。目前这个仓库不仅禁用了 luma processing（0xfc8e），还禁用了 chroma processing（0xfc8f）。</p>\n<p>P.S. 实测发现，把 <code>0xfc8e</code> 改为 <code>0x11</code> 只对 <code>3840x2160 (16:9) - 30, 60 FPS - CS 709 - NV12 (420v)</code> 模式生效；对 <code>3840x2160 (16:9) - 30 FPS - CS 709 - NV12 (420v)</code> 模式则无效：前者画面清晰、颜色正确，后者画面模糊、颜色也不对。具体原因尚未深入分析。</p>\n<h2 id=\"采集卡的行为\">采集卡的行为</h2>\n<h3 id=\"颜色处理过程\">颜色处理过程</h3>\n<p>通过逆向，找到了采集卡对颜色处理的过程：</p>\n<ol>\n<li>把 RGB 转成 Y/ΔR/ΔB</li>\n<li>luma processing 第一步（取决于 0xfc8e[0]）：给 Y 加上一个数（offset），这个数是把 0xfc90 寄存器的值当成有符号 int8 的值</li>\n<li>luma processing 第二步（取决于 0xfc8e[4]）：给 Y 乘一个数（gain），这个数等于 0xfc91 寄存器的值除以 128</li>\n<li>chroma saturation（取决于 0xfc8f[0]）：给 ΔR 和 ΔB 乘上一个数（gain），这个数等于 0xfc92 寄存器的值除以 128</li>\n<li>chroma hue（取决于 0xfc8f[4]）：对 ΔR 和 ΔB 进行旋转，旋转的角度等于 0xfc93 寄存器的值除以 256 乘以 360 度</li>\n<li>Y/ΔR/ΔB 再转换到最终的颜色输出</li>\n</ol>\n<p>把 <code>0xfc8e</code> 的 bit0/bit4 记作 <code>e0</code>/<code>e4</code>，<code>0xfc8f</code> 的 bit0/bit4 记作 <code>f0</code>/<code>f4</code>（1 表示 bypass），则 RGB 输入下 luma/chroma 的完整处理流程是：</p>\n<div class=\"language-text highlight\"><pre><span></span><code><span id=\"__span-5-1\"><a id=\"__codelineno-5-1\" name=\"__codelineno-5-1\" href=\"#__codelineno-5-1\"></a># 输入 R, G, B ∈ [0, 255]\n</span><span id=\"__span-5-2\"><a id=\"__codelineno-5-2\" name=\"__codelineno-5-2\" href=\"#__codelineno-5-2\"></a>e0 = fc8e &amp; 0x01\n</span><span id=\"__span-5-3\"><a id=\"__codelineno-5-3\" name=\"__codelineno-5-3\" href=\"#__codelineno-5-3\"></a>e4 = (fc8e &gt;&gt; 4) &amp; 1\n</span><span id=\"__span-5-4\"><a id=\"__codelineno-5-4\" name=\"__codelineno-5-4\" href=\"#__codelineno-5-4\"></a>f0 = fc8f &amp; 0x01\n</span><span id=\"__span-5-5\"><a id=\"__codelineno-5-5\" name=\"__codelineno-5-5\" href=\"#__codelineno-5-5\"></a>f4 = (fc8f &gt;&gt; 4) &amp; 1\n</span><span id=\"__span-5-6\"><a id=\"__codelineno-5-6\" name=\"__codelineno-5-6\" href=\"#__codelineno-5-6\"></a>\n</span><span id=\"__span-5-7\"><a id=\"__codelineno-5-7\" name=\"__codelineno-5-7\" href=\"#__codelineno-5-7\"></a># Rec.709 luma\n</span><span id=\"__span-5-8\"><a id=\"__codelineno-5-8\" name=\"__codelineno-5-8\" href=\"#__codelineno-5-8\"></a>Y  = 0.2126*R + 0.7152*G + 0.0722*B\n</span><span id=\"__span-5-9\"><a id=\"__codelineno-5-9\" name=\"__codelineno-5-9\" href=\"#__codelineno-5-9\"></a>ΔR = R - Y\n</span><span id=\"__span-5-10\"><a id=\"__codelineno-5-10\" name=\"__codelineno-5-10\" href=\"#__codelineno-5-10\"></a>ΔB = B - Y\n</span><span id=\"__span-5-11\"><a id=\"__codelineno-5-11\" name=\"__codelineno-5-11\" href=\"#__codelineno-5-11\"></a>\n</span><span id=\"__span-5-12\"><a id=\"__codelineno-5-12\" name=\"__codelineno-5-12\" href=\"#__codelineno-5-12\"></a># 0xfc90 按 signed int8 解释（fc90 为 0–255 的寄存器原值）\n</span><span id=\"__span-5-13\"><a id=\"__codelineno-5-13\" name=\"__codelineno-5-13\" href=\"#__codelineno-5-13\"></a>o = fc90 if fc90 &lt; 0x80 else fc90 - 0x100\n</span><span id=\"__span-5-14\"><a id=\"__codelineno-5-14\" name=\"__codelineno-5-14\" href=\"#__codelineno-5-14\"></a>\n</span><span id=\"__span-5-15\"><a id=\"__codelineno-5-15\" name=\"__codelineno-5-15\" href=\"#__codelineno-5-15\"></a>Y' = Y\n</span><span id=\"__span-5-16\"><a id=\"__codelineno-5-16\" name=\"__codelineno-5-16\" href=\"#__codelineno-5-16\"></a>if e0 == 0:\n</span><span id=\"__span-5-17\"><a id=\"__codelineno-5-17\" name=\"__codelineno-5-17\" href=\"#__codelineno-5-17\"></a>    Y' = clip(Y' + o, 0, 255)\n</span><span id=\"__span-5-18\"><a id=\"__codelineno-5-18\" name=\"__codelineno-5-18\" href=\"#__codelineno-5-18\"></a>if e4 == 0:\n</span><span id=\"__span-5-19\"><a id=\"__codelineno-5-19\" name=\"__codelineno-5-19\" href=\"#__codelineno-5-19\"></a>    Y' = clip(Y' * fc91/128, 0, 255)\n</span><span id=\"__span-5-20\"><a id=\"__codelineno-5-20\" name=\"__codelineno-5-20\" href=\"#__codelineno-5-20\"></a>\n</span><span id=\"__span-5-21\"><a id=\"__codelineno-5-21\" name=\"__codelineno-5-21\" href=\"#__codelineno-5-21\"></a># saturation 与 hue 都是线性变换，先后顺序可交换\n</span><span id=\"__span-5-22\"><a id=\"__codelineno-5-22\" name=\"__codelineno-5-22\" href=\"#__codelineno-5-22\"></a>if f0 == 0:\n</span><span id=\"__span-5-23\"><a id=\"__codelineno-5-23\" name=\"__codelineno-5-23\" href=\"#__codelineno-5-23\"></a>    ΔR = ΔR * fc92/128\n</span><span id=\"__span-5-24\"><a id=\"__codelineno-5-24\" name=\"__codelineno-5-24\" href=\"#__codelineno-5-24\"></a>    ΔB = ΔB * fc92/128\n</span><span id=\"__span-5-25\"><a id=\"__codelineno-5-25\" name=\"__codelineno-5-25\" href=\"#__codelineno-5-25\"></a>\n</span><span id=\"__span-5-26\"><a id=\"__codelineno-5-26\" name=\"__codelineno-5-26\" href=\"#__codelineno-5-26\"></a>θ = fc93 * 360/256        # 单位：度\n</span><span id=\"__span-5-27\"><a id=\"__codelineno-5-27\" name=\"__codelineno-5-27\" href=\"#__codelineno-5-27\"></a>if f4 == 0:\n</span><span id=\"__span-5-28\"><a id=\"__codelineno-5-28\" name=\"__codelineno-5-28\" href=\"#__codelineno-5-28\"></a>    ΔR, ΔB = ΔR*cosθ - ΔB*sinθ, ΔR*sinθ + ΔB*cosθ\n</span><span id=\"__span-5-29\"><a id=\"__codelineno-5-29\" name=\"__codelineno-5-29\" href=\"#__codelineno-5-29\"></a>\n</span><span id=\"__span-5-30\"><a id=\"__codelineno-5-30\" name=\"__codelineno-5-30\" href=\"#__codelineno-5-30\"></a>ΔR = clip(ΔR, -200.8, 200.8)\n</span><span id=\"__span-5-31\"><a id=\"__codelineno-5-31\" name=\"__codelineno-5-31\" href=\"#__codelineno-5-31\"></a>ΔB = clip(ΔB, -236.6, 236.6)\n</span><span id=\"__span-5-32\"><a id=\"__codelineno-5-32\" name=\"__codelineno-5-32\" href=\"#__codelineno-5-32\"></a>\n</span><span id=\"__span-5-33\"><a id=\"__codelineno-5-33\" name=\"__codelineno-5-33\" href=\"#__codelineno-5-33\"></a># 0.10094 = KB/KG，0.29725 = KR/KG\n</span><span id=\"__span-5-34\"><a id=\"__codelineno-5-34\" name=\"__codelineno-5-34\" href=\"#__codelineno-5-34\"></a>R' = round(clip(Y' + ΔR, 0, 255))\n</span><span id=\"__span-5-35\"><a id=\"__codelineno-5-35\" name=\"__codelineno-5-35\" href=\"#__codelineno-5-35\"></a>G' = round(clip(Y' - 0.10094*ΔB - 0.29725*ΔR, 0, 255))\n</span><span id=\"__span-5-36\"><a id=\"__codelineno-5-36\" name=\"__codelineno-5-36\" href=\"#__codelineno-5-36\"></a>B' = round(clip(Y' + ΔB, 0, 255))\n</span></code></pre></div>\n<p>其中 <code>clip(x, lo, hi) = min(max(x, lo), hi)</code>，<code>round</code> 为四舍五入；<code>ΔR</code>/<code>ΔB</code> 的 clip 在 saturation/hue 之后，所以旋转可能把原本合法的分量转出范围。</p>\n<h3 id=\"交互式计算器\">交互式计算器</h3>\n<p>为了更好地演示这个颜色处理流程，访问<a href=\"../../../../../ms2130s-color-processing.html\">交互式计算器</a>以看到 MS2130S 内部每个像素经过哪些计算、最终变成什么。</p>\n<h3 id=\"已确认的-ms2130s-寄存器位\">已确认的 MS2130S 寄存器位</h3>\n<p>下面列出经过逆向工程，确定的 MS2130S 芯片的一些寄存器的功能。</p>\n<h4 id=\"0x3c020x3c03---hdmi-时序的-h-total\"><code>0x3c02/0x3c03</code> - HDMI 时序的 H total</h4>\n<h4 id=\"0x3c040x3c05---hdmi-时序的-v-total\"><code>0x3c04/0x3c05</code> - HDMI 时序的 V total</h4>\n<h4 id=\"0x3c060x3c07---hdmi-时序的-h-active\"><code>0x3c06/0x3c07</code> - HDMI 时序的 H active</h4>\n<h4 id=\"0x3c080x3c09---hdmi-时序的-v-active\"><code>0x3c08/0x3c09</code> - HDMI 时序的 V active</h4>\n<h4 id=\"0x3c0a0x3c0b---hdmi-时序的-pixel-clock单位-10-khz\"><code>0x3c0a/0x3c0b</code> - HDMI 时序的 pixel clock（单位 10 kHz）</h4>\n<h4 id=\"0x3c0c0x3c0d---hdmi-时序的-fps单位-001-hz\"><code>0x3c0c/0x3c0d</code> - HDMI 时序的 FPS（单位 0.01 Hz）</h4>\n<h4 id=\"0x3c41---cea-vic\"><code>0x3c41</code> - CEA VIC</h4>\n<p>记录了输入信号的时序是哪种 CEA VIC 标准时序，如果非 CEA 标准时序，则为 0</p>\n<h4 id=\"0x3c420x3c43---hdmi-时序的-pixel-clock单位-10-khz\"><code>0x3c42/0x3c43</code> - HDMI 时序的 pixel clock（单位 10 kHz）</h4>\n<h4 id=\"0x3c47---hdmi-输入的颜色格式\"><code>0x3c47</code> - HDMI 输入的颜色格式</h4>\n<table>\n<thead>\n<tr>\n<th style=\"text-align: right;\">位</th>\n<th>功能</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td style=\"text-align: right;\">1:0</td>\n<td><code>0</code> = RGB 4:4:4，<code>1</code> = YCbCr 4:2:2，<code>2</code> = YCbCr 4:4:4, <code>3</code> = YCbCr 4:2:0，对应 AVI InfoFrame Y2:Y0</td>\n</tr>\n</tbody>\n</table>\n<h4 id=\"0x3c4a---hdmi-输入的-rgb-颜色范围\"><code>0x3c4a</code> - HDMI 输入的 RGB 颜色范围</h4>\n<table>\n<thead>\n<tr>\n<th style=\"text-align: right;\">位</th>\n<th>功能</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td style=\"text-align: right;\">1:0</td>\n<td><code>1</code> = RGB Limited, <code>2</code> = RGB Full，对应 AVI InfoFrame Q1:Q0</td>\n</tr>\n</tbody>\n</table>\n<h4 id=\"0xf130--视频管线实际使用的输入色彩格式选择\"><code>0xf130</code> — 视频管线实际使用的输入色彩格式选择</h4>\n<table>\n<thead>\n<tr>\n<th style=\"text-align: right;\">位</th>\n<th>功能</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td style=\"text-align: right;\">1:0</td>\n<td><code>0</code> = RGB 4:4:4，<code>1</code> = YCbCr 4:4:4，<code>2</code> = YCbCr 4:2:2, <code>3</code> = YCbCr 4:2:0</td>\n</tr>\n</tbody>\n</table>\n<p>通常，固件会根据 0x3c47 寄存器的值来写入 0xf130。</p>\n<h4 id=\"0xfc8e--luma-processing\"><code>0xfc8e</code> — luma processing</h4>\n<table>\n<thead>\n<tr>\n<th style=\"text-align: right;\">位</th>\n<th>功能</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td style=\"text-align: right;\">0</td>\n<td>1 = bypass <code>0xfc90</code> offset 级</td>\n</tr>\n<tr>\n<td style=\"text-align: right;\">4</td>\n<td>1 = bypass <code>0xfc91</code> gain 级</td>\n</tr>\n</tbody>\n</table>\n<table>\n<thead>\n<tr>\n<th style=\"text-align: right;\"><code>0xfc8e</code></th>\n<th>offset <code>0xfc90</code></th>\n<th>gain <code>0xfc91</code></th>\n<th>公式</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td style=\"text-align: right;\"><code>0x00</code></td>\n<td>on</td>\n<td>on</td>\n<td><code>clip(clip(Y + fc90) * fc91/128)</code></td>\n</tr>\n<tr>\n<td style=\"text-align: right;\"><code>0x01</code></td>\n<td>bypass</td>\n<td>on</td>\n<td><code>clip(Y * fc91/128)</code></td>\n</tr>\n<tr>\n<td style=\"text-align: right;\"><code>0x10</code></td>\n<td>on</td>\n<td>bypass</td>\n<td><code>clip(Y + fc90)</code></td>\n</tr>\n<tr>\n<td style=\"text-align: right;\"><code>0x11</code></td>\n<td>bypass</td>\n<td>bypass</td>\n<td><code>Y</code></td>\n</tr>\n</tbody>\n</table>\n<h4 id=\"0xfc8f--chroma-processing\"><code>0xfc8f</code> — chroma processing</h4>\n<table>\n<thead>\n<tr>\n<th style=\"text-align: right;\">位</th>\n<th>功能</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td style=\"text-align: right;\">0</td>\n<td>1 = bypass <code>0xfc92</code> saturation 级</td>\n</tr>\n<tr>\n<td style=\"text-align: right;\">4</td>\n<td>1 = bypass <code>0xfc93</code> hue 级</td>\n</tr>\n</tbody>\n</table>\n<table>\n<thead>\n<tr>\n<th style=\"text-align: right;\"><code>0xfc8f</code></th>\n<th>saturation <code>0xfc92</code></th>\n<th>hue <code>0xfc93</code></th>\n<th>公式</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td style=\"text-align: right;\"><code>0x00</code></td>\n<td>on</td>\n<td>on</td>\n<td><code>clip(rotate(ΔR, ΔB) * fc92/128)</code></td>\n</tr>\n<tr>\n<td style=\"text-align: right;\"><code>0x01</code></td>\n<td>bypass</td>\n<td>on</td>\n<td><code>clip(rotate(ΔR, ΔB))</code></td>\n</tr>\n<tr>\n<td style=\"text-align: right;\"><code>0x10</code></td>\n<td>on</td>\n<td>bypass</td>\n<td><code>clip((ΔR, ΔB) * fc92/128)</code></td>\n</tr>\n<tr>\n<td style=\"text-align: right;\"><code>0x11</code></td>\n<td>bypass</td>\n<td>bypass</td>\n<td><code>(ΔR, ΔB)</code></td>\n</tr>\n</tbody>\n</table>\n<p>其中 <code>rotate(ΔR, ΔB)</code> 表示把 <code>(ΔR, ΔB)</code> 旋转 <code>θ = fc93 * 360/256°</code>：</p>\n<p><code>rotate(ΔR, ΔB) = (ΔR * cosθ - ΔB * sinθ, ΔR * sinθ + ΔB * cosθ)</code></p>\n<p><code>clip</code> 把 <code>ΔR</code> 限制到 <code>[-200.8, 200.8]</code>、<code>ΔB</code> 限制到 <code>[-236.6, 236.6]</code>。</p>\n<h4 id=\"0xfc900xfc93\"><code>0xfc90</code>–<code>0xfc93</code></h4>\n<table>\n<thead>\n<tr>\n<th>寄存器</th>\n<th>功能</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>0xfc90</code></td>\n<td>luma offset，signed int8</td>\n</tr>\n<tr>\n<td><code>0xfc91</code></td>\n<td>luma gain，<code>fc91/128</code></td>\n</tr>\n<tr>\n<td><code>0xfc92</code></td>\n<td>saturation，<code>fc92/128</code></td>\n</tr>\n<tr>\n<td><code>0xfc93</code></td>\n<td>hue，<code>fc93 × 360/256°</code></td>\n</tr>\n</tbody>\n</table>\n<h2 id=\"总结\">总结</h2>\n<p>其实 MS2130S 这款芯片在网络上已经有很多现成的研究，从寄存器用法、hidapi 访问到固件补丁，都能找到前人的成果。这次能比较顺利地定位并解决问题，很大程度上是站在这些探索的肩膀上，在此对这些作者表示感谢。</p>\n<p>相关项目链接整理如下：</p>\n<ul>\n<li><a href=\"https://github.com/steve-m/hsdaoh\">steve-m/hsdaoh</a>：通过 hidapi 访问 MS2130S 寄存器的库，本文从 host 端修改 <code>0xfc8e</code> 的思路就来自这里。</li>\n<li><a href=\"https://github.com/steve-m/ms2130_patcher\">steve-m/ms2130_patcher</a>：直接给固件打补丁、持久化寄存器配置的工具，是本文固件补丁的重要参考。</li>\n<li><a href=\"https://github.com/steve-m/ms213x_flash\">steve-m/ms213x_flash</a>：用来导出/烧写 MS213x 固件的工具，本文用它导出了绿联 95348 的原始固件。</li>\n</ul>\n<p>这些项目大多出自 <a href=\"https://github.com/steve-m\">steve-m</a> 之手，感谢他的开源工作。</p>\n<h2 id=\"附录macbookair\">附录：MacBookAir</h2>\n<p>MateBook Pro 的问题解决了，但 MacBookAir 又出现了问题，即使关闭了 luma 和 chroma processing：</p>\n<ul>\n<li>rgb 0,0,0 -&gt; rgb 16,16,16</li>\n<li>rgb 64,64,64 -&gt; rgb 64,60,54</li>\n<li>rgb 128,128,128 -&gt; rgb 116,109,101</li>\n<li>rgb 192,192,192 -&gt; rgb 174,164,148</li>\n<li>rgb 255,255,255 -&gt; rgb 235,221,199</li>\n<li>rgb 64,0,0 -&gt; rgb 61,16,19</li>\n<li>rgb 128,0,0 -&gt; rgb 112,18,22</li>\n<li>rgb 192,0,0 -&gt; rgb 170,19,24</li>\n<li>rgb 255,0,0 -&gt; rgb 226,18,27</li>\n<li>rgb 0,64,0 -&gt; rgb 30,60,24</li>\n<li>rgb 0,128,0 -&gt; rgb 42,108,29</li>\n<li>rgb 0,192,0 -&gt; rgb 60,162,37</li>\n<li>rgb 0,255,0 -&gt; rgb 75,221,46</li>\n<li>rgb 0,0,64 -&gt; rgb 21,18,55</li>\n<li>rgb 0,0,128 -&gt; rgb 25,20,99</li>\n<li>rgb 0,0,192 -&gt; rgb 30,23,148</li>\n<li>rgb 0,0,255 -&gt; rgb 37,26,199</li>\n</ul>\n<p>目前的怀疑是，macOS 读取了 UG307-95348 的 EDID 后，认为它的色彩空间并不是 sRGB，所以做了一次转换，而上面这个转换的过程，其实是 macOS 做的，采集卡侧已经没有做进一步的处理了。于是在 macOS 侧，把 UGREEN-95348 显示器的 Color profile 设置成 sRGB IEC61966-2.1 后，重新测量：</p>\n<ul>\n<li>rgb 0,0,0 -&gt; rgb 16,16,16</li>\n<li>rgb 64,64,64 -&gt; rgb 71,67,61</li>\n<li>rgb 128,128,128 -&gt; rgb 126,118,108</li>\n<li>rgb 192,192,192 -&gt; rgb 180,170,154</li>\n<li>rgb 255,255,255 -&gt; rgb 236,222,202</li>\n<li>rgb 64,0,0 -&gt; rgb 68,16,16</li>\n<li>rgb 128,0,0 -&gt; rgb 123,16,15</li>\n<li>rgb 192,0,0 -&gt; rgb 177,16,16</li>\n<li>rgb 255,0,0 -&gt; rgb 231,14,16</li>\n<li>rgb 0,64,0 -&gt; rgb 23,66,16</li>\n<li>rgb 0,128,0 -&gt; rgb 42,120,13</li>\n<li>rgb 0,192,0 -&gt; rgb 59,172,14</li>\n<li>rgb 0,255,0 -&gt; rgb 75,222,13</li>\n<li>rgb 0,0,64 -&gt; rgb 18,16,62</li>\n<li>rgb 0,0,128 -&gt; rgb 23,16,111</li>\n<li>rgb 0,0,192 -&gt; rgb 33,18,162</li>\n<li>rgb 0,0,255 -&gt; rgb 42,20,210</li>\n</ul>\n<p>还是有偏差。</p>\n<p>为了解决这个问题，最后让 AI 写了一个脚本，来生成一个 LUT 来校色：</p>\n<ol>\n<li>在 MacBookAir 上访问 <a href=\"https://jia.je/ms2130s-calibration.html\">https://jia.je/ms2130s-calibration.html</a>，全屏输出到采集卡</li>\n<li>在采集侧运行 <a href=\"../../../../calibrate.py\">calibrate.py</a>，得到 capture-fix.cube 文件</li>\n<li>在 OBS 里，给采集卡新增一个 Apply LUT 的 Effect Filter，选择第二步生成的 capture-fix.cube 文件</li>\n</ol>\n<p>关掉 luma 和 chroma processing，Apply LUT 后的最终效果，颜色误差小了很多：</p>\n<ul>\n<li>rgb 0,0,0 -&gt; rgb 0,0,0</li>\n<li>rgb 64,64,64 -&gt; rgb 65,65,62</li>\n<li>rgb 128,128,128 -&gt; rgb 133,128,133</li>\n<li>rgb 192,192,192 -&gt; rgb 195,194,193</li>\n<li>rgb 255,255,255 -&gt; rgb 252,254,251</li>\n<li>rgb 64,0,0 -&gt; rgb 70,0,4</li>\n<li>rgb 128,0,0 -&gt; rgb 129,0,4</li>\n<li>rgb 192,0,0 -&gt; rgb 185,0,6</li>\n<li>rgb 255,0,0 -&gt; rgb 254,0,4</li>\n</ul>\n<p>这个 .cube 文件把 RGB 从 (0,0,0) 到 (1,1,1) 的空间切分成 33x33x33 的 Grid，把每个格点做一个映射，所以它的主要内容就是这 33x33x33=35937 各点映射后的 RGB。然后实际的颜色不一定在格点上，就会做一个插值：</p>\n<div class=\"language-text highlight\"><pre><span></span><code><span id=\"__span-6-1\"><a id=\"__codelineno-6-1\" name=\"__codelineno-6-1\" href=\"#__codelineno-6-1\"></a>TITLE \"MS2130S capture fix\"\n</span><span id=\"__span-6-2\"><a id=\"__codelineno-6-2\" name=\"__codelineno-6-2\" href=\"#__codelineno-6-2\"></a>LUT_3D_SIZE 33\n</span><span id=\"__span-6-3\"><a id=\"__codelineno-6-3\" name=\"__codelineno-6-3\" href=\"#__codelineno-6-3\"></a>DOMAIN_MIN 0.0 0.0 0.0\n</span><span id=\"__span-6-4\"><a id=\"__codelineno-6-4\" name=\"__codelineno-6-4\" href=\"#__codelineno-6-4\"></a>DOMAIN_MAX 1.0 1.0 1.0\n</span><span id=\"__span-6-5\"><a id=\"__codelineno-6-5\" name=\"__codelineno-6-5\" href=\"#__codelineno-6-5\"></a>\n</span><span id=\"__span-6-6\"><a id=\"__codelineno-6-6\" name=\"__codelineno-6-6\" href=\"#__codelineno-6-6\"></a>0.000000 0.000000 0.000000      # 输入 (0,0,0)        -&gt; 输出\n</span><span id=\"__span-6-7\"><a id=\"__codelineno-6-7\" name=\"__codelineno-6-7\" href=\"#__codelineno-6-7\"></a>0.000000 0.000000 0.000000      # 输入 (1/32,0,0)\n</span><span id=\"__span-6-8\"><a id=\"__codelineno-6-8\" name=\"__codelineno-6-8\" href=\"#__codelineno-6-8\"></a>0.001452 0.000000 0.000000      # 输入 (2/32,0,0)\n</span><span id=\"__span-6-9\"><a id=\"__codelineno-6-9\" name=\"__codelineno-6-9\" href=\"#__codelineno-6-9\"></a>...\n</span><span id=\"__span-6-10\"><a id=\"__codelineno-6-10\" name=\"__codelineno-6-10\" href=\"#__codelineno-6-10\"></a>1.000000 1.000000 1.000000      # 输入 (1,1,1)\n</span></code></pre></div>\n<h2 id=\"附录\">附录</h2>\n<p>以下是这个采集卡原始固件的 EDID：</p>\n<div class=\"language-text highlight\"><pre><span></span><code><span id=\"__span-7-1\"><a id=\"__codelineno-7-1\" name=\"__codelineno-7-1\" href=\"#__codelineno-7-1\"></a>00ffffffffffff0054f248538d0135012b230103803c2278022895a7554ea3260f5054010000d1c081c0010001000100010001000100023a801871382d40582c4500c48e2100001e9c45007251d01e206e28550055502100001e000000fd0018501e641e000a202020202020000000fc0055475245454e2d39353334380a01c002032d724c1f222120133e3d3c5f64676223090707830100006d030c001000003c200060010203e50e616066656a5e00a0a0a0295030202500b0133200000019640080a3a02b50b0103510b01332000000352f00a0a0a0295030202500b001320000000000000000000000000000000000000000000000000000000000000058\n</span></code></pre></div>\n<p>用 <a href=\"https://people.freedesktop.org/~imirkin/edid-decode/\">edid-decode</a> 出来的结果：</p>\n<div class=\"language-text highlight\"><pre><span></span><code><span id=\"__span-8-1\"><a id=\"__codelineno-8-1\" name=\"__codelineno-8-1\" href=\"#__codelineno-8-1\"></a>edid-decode (hex):\n</span><span id=\"__span-8-2\"><a id=\"__codelineno-8-2\" name=\"__codelineno-8-2\" href=\"#__codelineno-8-2\"></a>\n</span><span id=\"__span-8-3\"><a id=\"__codelineno-8-3\" name=\"__codelineno-8-3\" href=\"#__codelineno-8-3\"></a>00 ff ff ff ff ff ff 00 54 f2 48 53 8d 01 35 01\n</span><span id=\"__span-8-4\"><a id=\"__codelineno-8-4\" name=\"__codelineno-8-4\" href=\"#__codelineno-8-4\"></a>2b 23 01 03 80 3c 22 78 02 28 95 a7 55 4e a3 26\n</span><span id=\"__span-8-5\"><a id=\"__codelineno-8-5\" name=\"__codelineno-8-5\" href=\"#__codelineno-8-5\"></a>0f 50 54 01 00 00 d1 c0 81 c0 01 00 01 00 01 00\n</span><span id=\"__span-8-6\"><a id=\"__codelineno-8-6\" name=\"__codelineno-8-6\" href=\"#__codelineno-8-6\"></a>01 00 01 00 01 00 02 3a 80 18 71 38 2d 40 58 2c\n</span><span id=\"__span-8-7\"><a id=\"__codelineno-8-7\" name=\"__codelineno-8-7\" href=\"#__codelineno-8-7\"></a>45 00 c4 8e 21 00 00 1e 9c 45 00 72 51 d0 1e 20\n</span><span id=\"__span-8-8\"><a id=\"__codelineno-8-8\" name=\"__codelineno-8-8\" href=\"#__codelineno-8-8\"></a>6e 28 55 00 55 50 21 00 00 1e 00 00 00 fd 00 18\n</span><span id=\"__span-8-9\"><a id=\"__codelineno-8-9\" name=\"__codelineno-8-9\" href=\"#__codelineno-8-9\"></a>50 1e 64 1e 00 0a 20 20 20 20 20 20 00 00 00 fc\n</span><span id=\"__span-8-10\"><a id=\"__codelineno-8-10\" name=\"__codelineno-8-10\" href=\"#__codelineno-8-10\"></a>00 55 47 52 45 45 4e 2d 39 35 33 34 38 0a 01 c0\n</span><span id=\"__span-8-11\"><a id=\"__codelineno-8-11\" name=\"__codelineno-8-11\" href=\"#__codelineno-8-11\"></a>\n</span><span id=\"__span-8-12\"><a id=\"__codelineno-8-12\" name=\"__codelineno-8-12\" href=\"#__codelineno-8-12\"></a>02 03 2d 72 4c 1f 22 21 20 13 3e 3d 3c 5f 64 67\n</span><span id=\"__span-8-13\"><a id=\"__codelineno-8-13\" name=\"__codelineno-8-13\" href=\"#__codelineno-8-13\"></a>62 23 09 07 07 83 01 00 00 6d 03 0c 00 10 00 00\n</span><span id=\"__span-8-14\"><a id=\"__codelineno-8-14\" name=\"__codelineno-8-14\" href=\"#__codelineno-8-14\"></a>3c 20 00 60 01 02 03 e5 0e 61 60 66 65 6a 5e 00\n</span><span id=\"__span-8-15\"><a id=\"__codelineno-8-15\" name=\"__codelineno-8-15\" href=\"#__codelineno-8-15\"></a>a0 a0 a0 29 50 30 20 25 00 b0 13 32 00 00 00 19\n</span><span id=\"__span-8-16\"><a id=\"__codelineno-8-16\" name=\"__codelineno-8-16\" href=\"#__codelineno-8-16\"></a>64 00 80 a3 a0 2b 50 b0 10 35 10 b0 13 32 00 00\n</span><span id=\"__span-8-17\"><a id=\"__codelineno-8-17\" name=\"__codelineno-8-17\" href=\"#__codelineno-8-17\"></a>00 35 2f 00 a0 a0 a0 29 50 30 20 25 00 b0 01 32\n</span><span id=\"__span-8-18\"><a id=\"__codelineno-8-18\" name=\"__codelineno-8-18\" href=\"#__codelineno-8-18\"></a>00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00\n</span><span id=\"__span-8-19\"><a id=\"__codelineno-8-19\" name=\"__codelineno-8-19\" href=\"#__codelineno-8-19\"></a>00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 58\n</span><span id=\"__span-8-20\"><a id=\"__codelineno-8-20\" name=\"__codelineno-8-20\" href=\"#__codelineno-8-20\"></a>\n</span><span id=\"__span-8-21\"><a id=\"__codelineno-8-21\" name=\"__codelineno-8-21\" href=\"#__codelineno-8-21\"></a>----------------\n</span><span id=\"__span-8-22\"><a id=\"__codelineno-8-22\" name=\"__codelineno-8-22\" href=\"#__codelineno-8-22\"></a>\n</span><span id=\"__span-8-23\"><a id=\"__codelineno-8-23\" name=\"__codelineno-8-23\" href=\"#__codelineno-8-23\"></a>Block 0, Base EDID:\n</span><span id=\"__span-8-24\"><a id=\"__codelineno-8-24\" name=\"__codelineno-8-24\" href=\"#__codelineno-8-24\"></a>  EDID Structure Version &amp; Revision: 1.3\n</span><span id=\"__span-8-25\"><a id=\"__codelineno-8-25\" name=\"__codelineno-8-25\" href=\"#__codelineno-8-25\"></a>  Vendor &amp; Product Identification:\n</span><span id=\"__span-8-26\"><a id=\"__codelineno-8-26\" name=\"__codelineno-8-26\" href=\"#__codelineno-8-26\"></a>    Manufacturer: UGR\n</span><span id=\"__span-8-27\"><a id=\"__codelineno-8-27\" name=\"__codelineno-8-27\" href=\"#__codelineno-8-27\"></a>    Model: 21320\n</span><span id=\"__span-8-28\"><a id=\"__codelineno-8-28\" name=\"__codelineno-8-28\" href=\"#__codelineno-8-28\"></a>    Serial Number: 20251021\n</span><span id=\"__span-8-29\"><a id=\"__codelineno-8-29\" name=\"__codelineno-8-29\" href=\"#__codelineno-8-29\"></a>    Made in: week 43 of 2025\n</span><span id=\"__span-8-30\"><a id=\"__codelineno-8-30\" name=\"__codelineno-8-30\" href=\"#__codelineno-8-30\"></a>  Basic Display Parameters &amp; Features:\n</span><span id=\"__span-8-31\"><a id=\"__codelineno-8-31\" name=\"__codelineno-8-31\" href=\"#__codelineno-8-31\"></a>    Digital display\n</span><span id=\"__span-8-32\"><a id=\"__codelineno-8-32\" name=\"__codelineno-8-32\" href=\"#__codelineno-8-32\"></a>    Maximum image size: 60 cm x 34 cm\n</span><span id=\"__span-8-33\"><a id=\"__codelineno-8-33\" name=\"__codelineno-8-33\" href=\"#__codelineno-8-33\"></a>    Gamma: 2.20\n</span><span id=\"__span-8-34\"><a id=\"__codelineno-8-34\" name=\"__codelineno-8-34\" href=\"#__codelineno-8-34\"></a>    Monochrome or grayscale display\n</span><span id=\"__span-8-35\"><a id=\"__codelineno-8-35\" name=\"__codelineno-8-35\" href=\"#__codelineno-8-35\"></a>    First detailed timing is the preferred timing\n</span><span id=\"__span-8-36\"><a id=\"__codelineno-8-36\" name=\"__codelineno-8-36\" href=\"#__codelineno-8-36\"></a>  Color Characteristics:\n</span><span id=\"__span-8-37\"><a id=\"__codelineno-8-37\" name=\"__codelineno-8-37\" href=\"#__codelineno-8-37\"></a>    Red  : 0.6523, 0.3339\n</span><span id=\"__span-8-38\"><a id=\"__codelineno-8-38\" name=\"__codelineno-8-38\" href=\"#__codelineno-8-38\"></a>    Green: 0.3066, 0.6367\n</span><span id=\"__span-8-39\"><a id=\"__codelineno-8-39\" name=\"__codelineno-8-39\" href=\"#__codelineno-8-39\"></a>    Blue : 0.1503, 0.0595\n</span><span id=\"__span-8-40\"><a id=\"__codelineno-8-40\" name=\"__codelineno-8-40\" href=\"#__codelineno-8-40\"></a>    White: 0.3134, 0.3291\n</span><span id=\"__span-8-41\"><a id=\"__codelineno-8-41\" name=\"__codelineno-8-41\" href=\"#__codelineno-8-41\"></a>  Established Timings I &amp; II:\n</span><span id=\"__span-8-42\"><a id=\"__codelineno-8-42\" name=\"__codelineno-8-42\" href=\"#__codelineno-8-42\"></a>    DMT 0x09:   800x600    60.316541 Hz   4:3     37.879 kHz     40.000000 MHz\n</span><span id=\"__span-8-43\"><a id=\"__codelineno-8-43\" name=\"__codelineno-8-43\" href=\"#__codelineno-8-43\"></a>  Standard Timings:\n</span><span id=\"__span-8-44\"><a id=\"__codelineno-8-44\" name=\"__codelineno-8-44\" href=\"#__codelineno-8-44\"></a>    DMT 0x52:  1920x1080   60.000000 Hz  16:9     67.500 kHz    148.500000 MHz\n</span><span id=\"__span-8-45\"><a id=\"__codelineno-8-45\" name=\"__codelineno-8-45\" href=\"#__codelineno-8-45\"></a>    DMT 0x55:  1280x720    60.000000 Hz  16:9     45.000 kHz     74.250000 MHz\n</span><span id=\"__span-8-46\"><a id=\"__codelineno-8-46\" name=\"__codelineno-8-46\" href=\"#__codelineno-8-46\"></a>  Detailed Timing Descriptors:\n</span><span id=\"__span-8-47\"><a id=\"__codelineno-8-47\" name=\"__codelineno-8-47\" href=\"#__codelineno-8-47\"></a>    DTD 1:  1920x1080   60.000000 Hz  16:9     67.500 kHz    148.500000 MHz (708 mm x 398 mm)\n</span><span id=\"__span-8-48\"><a id=\"__codelineno-8-48\" name=\"__codelineno-8-48\" href=\"#__codelineno-8-48\"></a>                 Hfront   88 Hsync  44 Hback  148 Hpol P\n</span><span id=\"__span-8-49\"><a id=\"__codelineno-8-49\" name=\"__codelineno-8-49\" href=\"#__codelineno-8-49\"></a>                 Vfront    4 Vsync   5 Vback   36 Vpol P\n</span><span id=\"__span-8-50\"><a id=\"__codelineno-8-50\" name=\"__codelineno-8-50\" href=\"#__codelineno-8-50\"></a>    DTD 2:  1280x720   144.000000 Hz  16:9    108.000 kHz    178.200000 MHz (597 mm x 336 mm)\n</span><span id=\"__span-8-51\"><a id=\"__codelineno-8-51\" name=\"__codelineno-8-51\" href=\"#__codelineno-8-51\"></a>                 Hfront  110 Hsync  40 Hback  220 Hpol P\n</span><span id=\"__span-8-52\"><a id=\"__codelineno-8-52\" name=\"__codelineno-8-52\" href=\"#__codelineno-8-52\"></a>                 Vfront    5 Vsync   5 Vback   20 Vpol P\n</span><span id=\"__span-8-53\"><a id=\"__codelineno-8-53\" name=\"__codelineno-8-53\" href=\"#__codelineno-8-53\"></a>    Display Range Limits:\n</span><span id=\"__span-8-54\"><a id=\"__codelineno-8-54\" name=\"__codelineno-8-54\" href=\"#__codelineno-8-54\"></a>      Monitor ranges (GTF): 24-80 Hz V, 30-100 kHz H, max dotclock 300 MHz\n</span><span id=\"__span-8-55\"><a id=\"__codelineno-8-55\" name=\"__codelineno-8-55\" href=\"#__codelineno-8-55\"></a>    Display Product Name: 'UGREEN-95348'\n</span><span id=\"__span-8-56\"><a id=\"__codelineno-8-56\" name=\"__codelineno-8-56\" href=\"#__codelineno-8-56\"></a>  Extension blocks: 1\n</span><span id=\"__span-8-57\"><a id=\"__codelineno-8-57\" name=\"__codelineno-8-57\" href=\"#__codelineno-8-57\"></a>Checksum: 0xc0\n</span><span id=\"__span-8-58\"><a id=\"__codelineno-8-58\" name=\"__codelineno-8-58\" href=\"#__codelineno-8-58\"></a>\n</span><span id=\"__span-8-59\"><a id=\"__codelineno-8-59\" name=\"__codelineno-8-59\" href=\"#__codelineno-8-59\"></a>----------------\n</span><span id=\"__span-8-60\"><a id=\"__codelineno-8-60\" name=\"__codelineno-8-60\" href=\"#__codelineno-8-60\"></a>\n</span><span id=\"__span-8-61\"><a id=\"__codelineno-8-61\" name=\"__codelineno-8-61\" href=\"#__codelineno-8-61\"></a>Block 1, CTA-861 Extension Block:\n</span><span id=\"__span-8-62\"><a id=\"__codelineno-8-62\" name=\"__codelineno-8-62\" href=\"#__codelineno-8-62\"></a>  Revision: 3\n</span><span id=\"__span-8-63\"><a id=\"__codelineno-8-63\" name=\"__codelineno-8-63\" href=\"#__codelineno-8-63\"></a>  Basic audio support\n</span><span id=\"__span-8-64\"><a id=\"__codelineno-8-64\" name=\"__codelineno-8-64\" href=\"#__codelineno-8-64\"></a>  Supports YCbCr 4:4:4\n</span><span id=\"__span-8-65\"><a id=\"__codelineno-8-65\" name=\"__codelineno-8-65\" href=\"#__codelineno-8-65\"></a>  Supports YCbCr 4:2:2\n</span><span id=\"__span-8-66\"><a id=\"__codelineno-8-66\" name=\"__codelineno-8-66\" href=\"#__codelineno-8-66\"></a>  Native detailed modes: 2\n</span><span id=\"__span-8-67\"><a id=\"__codelineno-8-67\" name=\"__codelineno-8-67\" href=\"#__codelineno-8-67\"></a>  Video Data Block:\n</span><span id=\"__span-8-68\"><a id=\"__codelineno-8-68\" name=\"__codelineno-8-68\" href=\"#__codelineno-8-68\"></a>    VIC  31:  1920x1080   50.000000 Hz  16:9     56.250 kHz    148.500000 MHz\n</span><span id=\"__span-8-69\"><a id=\"__codelineno-8-69\" name=\"__codelineno-8-69\" href=\"#__codelineno-8-69\"></a>    VIC  34:  1920x1080   30.000000 Hz  16:9     33.750 kHz     74.250000 MHz\n</span><span id=\"__span-8-70\"><a id=\"__codelineno-8-70\" name=\"__codelineno-8-70\" href=\"#__codelineno-8-70\"></a>    VIC  33:  1920x1080   25.000000 Hz  16:9     28.125 kHz     74.250000 MHz\n</span><span id=\"__span-8-71\"><a id=\"__codelineno-8-71\" name=\"__codelineno-8-71\" href=\"#__codelineno-8-71\"></a>    VIC  32:  1920x1080   24.000000 Hz  16:9     27.000 kHz     74.250000 MHz\n</span><span id=\"__span-8-72\"><a id=\"__codelineno-8-72\" name=\"__codelineno-8-72\" href=\"#__codelineno-8-72\"></a>    VIC  19:  1280x720    50.000000 Hz  16:9     37.500 kHz     74.250000 MHz\n</span><span id=\"__span-8-73\"><a id=\"__codelineno-8-73\" name=\"__codelineno-8-73\" href=\"#__codelineno-8-73\"></a>    VIC  62:  1280x720    30.000000 Hz  16:9     22.500 kHz     74.250000 MHz\n</span><span id=\"__span-8-74\"><a id=\"__codelineno-8-74\" name=\"__codelineno-8-74\" href=\"#__codelineno-8-74\"></a>    VIC  61:  1280x720    25.000000 Hz  16:9     18.750 kHz     74.250000 MHz\n</span><span id=\"__span-8-75\"><a id=\"__codelineno-8-75\" name=\"__codelineno-8-75\" href=\"#__codelineno-8-75\"></a>    VIC  60:  1280x720    24.000000 Hz  16:9     18.000 kHz     59.400000 MHz\n</span><span id=\"__span-8-76\"><a id=\"__codelineno-8-76\" name=\"__codelineno-8-76\" href=\"#__codelineno-8-76\"></a>    VIC  95:  3840x2160   30.000000 Hz  16:9     67.500 kHz    297.000000 MHz\n</span><span id=\"__span-8-77\"><a id=\"__codelineno-8-77\" name=\"__codelineno-8-77\" href=\"#__codelineno-8-77\"></a>    VIC 100:  4096x2160   30.000000 Hz 256:135   67.500 kHz    297.000000 MHz\n</span><span id=\"__span-8-78\"><a id=\"__codelineno-8-78\" name=\"__codelineno-8-78\" href=\"#__codelineno-8-78\"></a>    VIC 103:  3840x2160   24.000000 Hz  64:27    54.000 kHz    297.000000 MHz\n</span><span id=\"__span-8-79\"><a id=\"__codelineno-8-79\" name=\"__codelineno-8-79\" href=\"#__codelineno-8-79\"></a>    VIC  98:  4096x2160   24.000000 Hz 256:135   54.000 kHz    297.000000 MHz\n</span><span id=\"__span-8-80\"><a id=\"__codelineno-8-80\" name=\"__codelineno-8-80\" href=\"#__codelineno-8-80\"></a>  Audio Data Block:\n</span><span id=\"__span-8-81\"><a id=\"__codelineno-8-81\" name=\"__codelineno-8-81\" href=\"#__codelineno-8-81\"></a>    Linear PCM:\n</span><span id=\"__span-8-82\"><a id=\"__codelineno-8-82\" name=\"__codelineno-8-82\" href=\"#__codelineno-8-82\"></a>      Max channels: 2\n</span><span id=\"__span-8-83\"><a id=\"__codelineno-8-83\" name=\"__codelineno-8-83\" href=\"#__codelineno-8-83\"></a>      Supported sample rates (kHz): 48 44.1 32\n</span><span id=\"__span-8-84\"><a id=\"__codelineno-8-84\" name=\"__codelineno-8-84\" href=\"#__codelineno-8-84\"></a>      Supported sample sizes (bits): 24 20 16\n</span><span id=\"__span-8-85\"><a id=\"__codelineno-8-85\" name=\"__codelineno-8-85\" href=\"#__codelineno-8-85\"></a>  Speaker Allocation Data Block:\n</span><span id=\"__span-8-86\"><a id=\"__codelineno-8-86\" name=\"__codelineno-8-86\" href=\"#__codelineno-8-86\"></a>    FL/FR - Front Left/Right\n</span><span id=\"__span-8-87\"><a id=\"__codelineno-8-87\" name=\"__codelineno-8-87\" href=\"#__codelineno-8-87\"></a>  Vendor-Specific Data Block (HDMI), OUI 00-0C-03:\n</span><span id=\"__span-8-88\"><a id=\"__codelineno-8-88\" name=\"__codelineno-8-88\" href=\"#__codelineno-8-88\"></a>    Source physical address: 1.0.0.0\n</span><span id=\"__span-8-89\"><a id=\"__codelineno-8-89\" name=\"__codelineno-8-89\" href=\"#__codelineno-8-89\"></a>    Maximum TMDS clock: 300 MHz\n</span><span id=\"__span-8-90\"><a id=\"__codelineno-8-90\" name=\"__codelineno-8-90\" href=\"#__codelineno-8-90\"></a>    Extended HDMI video details:\n</span><span id=\"__span-8-91\"><a id=\"__codelineno-8-91\" name=\"__codelineno-8-91\" href=\"#__codelineno-8-91\"></a>      HDMI VICs:\n</span><span id=\"__span-8-92\"><a id=\"__codelineno-8-92\" name=\"__codelineno-8-92\" href=\"#__codelineno-8-92\"></a>        HDMI VIC 1:  3840x2160   30.000000 Hz  16:9     67.500 kHz    297.000000 MHz\n</span><span id=\"__span-8-93\"><a id=\"__codelineno-8-93\" name=\"__codelineno-8-93\" href=\"#__codelineno-8-93\"></a>        HDMI VIC 2:  3840x2160   25.000000 Hz  16:9     56.250 kHz    297.000000 MHz\n</span><span id=\"__span-8-94\"><a id=\"__codelineno-8-94\" name=\"__codelineno-8-94\" href=\"#__codelineno-8-94\"></a>        HDMI VIC 3:  3840x2160   24.000000 Hz  16:9     54.000 kHz    297.000000 MHz\n</span><span id=\"__span-8-95\"><a id=\"__codelineno-8-95\" name=\"__codelineno-8-95\" href=\"#__codelineno-8-95\"></a>  YCbCr 4:2:0 Video Data Block:\n</span><span id=\"__span-8-96\"><a id=\"__codelineno-8-96\" name=\"__codelineno-8-96\" href=\"#__codelineno-8-96\"></a>    VIC  97:  3840x2160   60.000000 Hz  16:9    135.000 kHz    594.000000 MHz\n</span><span id=\"__span-8-97\"><a id=\"__codelineno-8-97\" name=\"__codelineno-8-97\" href=\"#__codelineno-8-97\"></a>    VIC  96:  3840x2160   50.000000 Hz  16:9    112.500 kHz    594.000000 MHz\n</span><span id=\"__span-8-98\"><a id=\"__codelineno-8-98\" name=\"__codelineno-8-98\" href=\"#__codelineno-8-98\"></a>    VIC 102:  4096x2160   60.000000 Hz 256:135  135.000 kHz    594.000000 MHz\n</span><span id=\"__span-8-99\"><a id=\"__codelineno-8-99\" name=\"__codelineno-8-99\" href=\"#__codelineno-8-99\"></a>    VIC 101:  4096x2160   50.000000 Hz 256:135  112.500 kHz    594.000000 MHz\n</span><span id=\"__span-8-100\"><a id=\"__codelineno-8-100\" name=\"__codelineno-8-100\" href=\"#__codelineno-8-100\"></a>  Detailed Timing Descriptors:\n</span><span id=\"__span-8-101\"><a id=\"__codelineno-8-101\" name=\"__codelineno-8-101\" href=\"#__codelineno-8-101\"></a>    DTD 3:  2560x1440   60.000199 Hz  16:9     88.860 kHz    241.700000 MHz (analog composite, sync-on-green, 944 mm x 531 mm)\n</span><span id=\"__span-8-102\"><a id=\"__codelineno-8-102\" name=\"__codelineno-8-102\" href=\"#__codelineno-8-102\"></a>                 Hfront   48 Hsync  32 Hback   80 Hpol N\n</span><span id=\"__span-8-103\"><a id=\"__codelineno-8-103\" name=\"__codelineno-8-103\" href=\"#__codelineno-8-103\"></a>                 Vfront    2 Vsync   5 Vback   34 Vpol N\n</span><span id=\"__span-8-104\"><a id=\"__codelineno-8-104\" name=\"__codelineno-8-104\" href=\"#__codelineno-8-104\"></a>    DTD 4:  2560x1440   49.997581 Hz  16:9     74.146 kHz    256.250000 MHz (analog composite, sync-on-green, 944 mm x 531 mm)\n</span><span id=\"__span-8-105\"><a id=\"__codelineno-8-105\" name=\"__codelineno-8-105\" href=\"#__codelineno-8-105\"></a>                 Hfront  176 Hsync 272 Hback  448 Hpol N\n</span><span id=\"__span-8-106\"><a id=\"__codelineno-8-106\" name=\"__codelineno-8-106\" href=\"#__codelineno-8-106\"></a>                 Vfront    3 Vsync   5 Vback   35 Vpol N\n</span><span id=\"__span-8-107\"><a id=\"__codelineno-8-107\" name=\"__codelineno-8-107\" href=\"#__codelineno-8-107\"></a>    DTD 5:  2560x1440   30.000099 Hz  16:9     44.430 kHz    120.850000 MHz (analog composite, sync-on-green, 944 mm x 513 mm)\n</span><span id=\"__span-8-108\"><a id=\"__codelineno-8-108\" name=\"__codelineno-8-108\" href=\"#__codelineno-8-108\"></a>                 Hfront   48 Hsync  32 Hback   80 Hpol N\n</span><span id=\"__span-8-109\"><a id=\"__codelineno-8-109\" name=\"__codelineno-8-109\" href=\"#__codelineno-8-109\"></a>                 Vfront    2 Vsync   5 Vback   34 Vpol N\n</span><span id=\"__span-8-110\"><a id=\"__codelineno-8-110\" name=\"__codelineno-8-110\" href=\"#__codelineno-8-110\"></a>Checksum: 0x58\n</span><span id=\"__span-8-111\"><a id=\"__codelineno-8-111\" name=\"__codelineno-8-111\" href=\"#__codelineno-8-111\"></a>\n</span><span id=\"__span-8-112\"><a id=\"__codelineno-8-112\" name=\"__codelineno-8-112\" href=\"#__codelineno-8-112\"></a>----------------\n</span><span id=\"__span-8-113\"><a id=\"__codelineno-8-113\" name=\"__codelineno-8-113\" href=\"#__codelineno-8-113\"></a>\n</span><span id=\"__span-8-114\"><a id=\"__codelineno-8-114\" name=\"__codelineno-8-114\" href=\"#__codelineno-8-114\"></a>Preferred Video Timing if only Block 0 is parsed:\n</span><span id=\"__span-8-115\"><a id=\"__codelineno-8-115\" name=\"__codelineno-8-115\" href=\"#__codelineno-8-115\"></a>  DTD   1:  1920x1080   60.000000 Hz  16:9     67.500 kHz    148.500000 MHz (708 mm x 398 mm)\n</span><span id=\"__span-8-116\"><a id=\"__codelineno-8-116\" name=\"__codelineno-8-116\" href=\"#__codelineno-8-116\"></a>                 Hfront   88 Hsync  44 Hback  148 Hpol P\n</span><span id=\"__span-8-117\"><a id=\"__codelineno-8-117\" name=\"__codelineno-8-117\" href=\"#__codelineno-8-117\"></a>                 Vfront    4 Vsync   5 Vback   36 Vpol P\n</span><span id=\"__span-8-118\"><a id=\"__codelineno-8-118\" name=\"__codelineno-8-118\" href=\"#__codelineno-8-118\"></a>\n</span><span id=\"__span-8-119\"><a id=\"__codelineno-8-119\" name=\"__codelineno-8-119\" href=\"#__codelineno-8-119\"></a>----------------\n</span><span id=\"__span-8-120\"><a id=\"__codelineno-8-120\" name=\"__codelineno-8-120\" href=\"#__codelineno-8-120\"></a>\n</span><span id=\"__span-8-121\"><a id=\"__codelineno-8-121\" name=\"__codelineno-8-121\" href=\"#__codelineno-8-121\"></a>Preferred Video Timings if Block 0 and CTA-861 Blocks are parsed:\n</span><span id=\"__span-8-122\"><a id=\"__codelineno-8-122\" name=\"__codelineno-8-122\" href=\"#__codelineno-8-122\"></a>  DTD   1:  1920x1080   60.000000 Hz  16:9     67.500 kHz    148.500000 MHz (708 mm x 398 mm)\n</span><span id=\"__span-8-123\"><a id=\"__codelineno-8-123\" name=\"__codelineno-8-123\" href=\"#__codelineno-8-123\"></a>                 Hfront   88 Hsync  44 Hback  148 Hpol P\n</span><span id=\"__span-8-124\"><a id=\"__codelineno-8-124\" name=\"__codelineno-8-124\" href=\"#__codelineno-8-124\"></a>                 Vfront    4 Vsync   5 Vback   36 Vpol P\n</span><span id=\"__span-8-125\"><a id=\"__codelineno-8-125\" name=\"__codelineno-8-125\" href=\"#__codelineno-8-125\"></a>  VIC  31:  1920x1080   50.000000 Hz  16:9     56.250 kHz    148.500000 MHz\n</span><span id=\"__span-8-126\"><a id=\"__codelineno-8-126\" name=\"__codelineno-8-126\" href=\"#__codelineno-8-126\"></a>                 Hfront  528 Hsync  44 Hback  148 Hpol P\n</span><span id=\"__span-8-127\"><a id=\"__codelineno-8-127\" name=\"__codelineno-8-127\" href=\"#__codelineno-8-127\"></a>                 Vfront    4 Vsync   5 Vback   36 Vpol P\n</span><span id=\"__span-8-128\"><a id=\"__codelineno-8-128\" name=\"__codelineno-8-128\" href=\"#__codelineno-8-128\"></a>\n</span><span id=\"__span-8-129\"><a id=\"__codelineno-8-129\" name=\"__codelineno-8-129\" href=\"#__codelineno-8-129\"></a>----------------\n</span><span id=\"__span-8-130\"><a id=\"__codelineno-8-130\" name=\"__codelineno-8-130\" href=\"#__codelineno-8-130\"></a>\n</span><span id=\"__span-8-131\"><a id=\"__codelineno-8-131\" name=\"__codelineno-8-131\" href=\"#__codelineno-8-131\"></a>Native Video Resolution if only Block 0 is parsed:\n</span><span id=\"__span-8-132\"><a id=\"__codelineno-8-132\" name=\"__codelineno-8-132\" href=\"#__codelineno-8-132\"></a>  1920x1080\n</span><span id=\"__span-8-133\"><a id=\"__codelineno-8-133\" name=\"__codelineno-8-133\" href=\"#__codelineno-8-133\"></a>\n</span><span id=\"__span-8-134\"><a id=\"__codelineno-8-134\" name=\"__codelineno-8-134\" href=\"#__codelineno-8-134\"></a>----------------\n</span><span id=\"__span-8-135\"><a id=\"__codelineno-8-135\" name=\"__codelineno-8-135\" href=\"#__codelineno-8-135\"></a>\n</span><span id=\"__span-8-136\"><a id=\"__codelineno-8-136\" name=\"__codelineno-8-136\" href=\"#__codelineno-8-136\"></a>Native Video Resolutions if Block 0 and CTA-861 Blocks are parsed:\n</span><span id=\"__span-8-137\"><a id=\"__codelineno-8-137\" name=\"__codelineno-8-137\" href=\"#__codelineno-8-137\"></a>  1280x720\n</span><span id=\"__span-8-138\"><a id=\"__codelineno-8-138\" name=\"__codelineno-8-138\" href=\"#__codelineno-8-138\"></a>  1920x1080\n</span><span id=\"__span-8-139\"><a id=\"__codelineno-8-139\" name=\"__codelineno-8-139\" href=\"#__codelineno-8-139\"></a>\n</span><span id=\"__span-8-140\"><a id=\"__codelineno-8-140\" name=\"__codelineno-8-140\" href=\"#__codelineno-8-140\"></a>----------------\n</span><span id=\"__span-8-141\"><a id=\"__codelineno-8-141\" name=\"__codelineno-8-141\" href=\"#__codelineno-8-141\"></a>\n</span><span id=\"__span-8-142\"><a id=\"__codelineno-8-142\" name=\"__codelineno-8-142\" href=\"#__codelineno-8-142\"></a>edid-decode SHA: 84ddf9155376 2021-10-03 10:37:45\n</span><span id=\"__span-8-143\"><a id=\"__codelineno-8-143\" name=\"__codelineno-8-143\" href=\"#__codelineno-8-143\"></a>\n</span><span id=\"__span-8-144\"><a id=\"__codelineno-8-144\" name=\"__codelineno-8-144\" href=\"#__codelineno-8-144\"></a>Warnings:\n</span><span id=\"__span-8-145\"><a id=\"__codelineno-8-145\" name=\"__codelineno-8-145\" href=\"#__codelineno-8-145\"></a>\n</span><span id=\"__span-8-146\"><a id=\"__codelineno-8-146\" name=\"__codelineno-8-146\" href=\"#__codelineno-8-146\"></a>Block 1, CTA-861 Extension Block:\n</span><span id=\"__span-8-147\"><a id=\"__codelineno-8-147\" name=\"__codelineno-8-147\" href=\"#__codelineno-8-147\"></a>  IT Video Formats are overscanned by default, but normally this should be underscanned.\n</span><span id=\"__span-8-148\"><a id=\"__codelineno-8-148\" name=\"__codelineno-8-148\" href=\"#__codelineno-8-148\"></a>\n</span><span id=\"__span-8-149\"><a id=\"__codelineno-8-149\" name=\"__codelineno-8-149\" href=\"#__codelineno-8-149\"></a>Failures:\n</span><span id=\"__span-8-150\"><a id=\"__codelineno-8-150\" name=\"__codelineno-8-150\" href=\"#__codelineno-8-150\"></a>\n</span><span id=\"__span-8-151\"><a id=\"__codelineno-8-151\" name=\"__codelineno-8-151\" href=\"#__codelineno-8-151\"></a>Block 0, Base EDID:\n</span><span id=\"__span-8-152\"><a id=\"__codelineno-8-152\" name=\"__codelineno-8-152\" href=\"#__codelineno-8-152\"></a>  Standard Timings: Use 0x0101 as the invalid Standard Timings code, not 0x0100.\n</span><span id=\"__span-8-153\"><a id=\"__codelineno-8-153\" name=\"__codelineno-8-153\" href=\"#__codelineno-8-153\"></a>  Standard Timings: Use 0x0101 as the invalid Standard Timings code, not 0x0100.\n</span><span id=\"__span-8-154\"><a id=\"__codelineno-8-154\" name=\"__codelineno-8-154\" href=\"#__codelineno-8-154\"></a>  Standard Timings: Use 0x0101 as the invalid Standard Timings code, not 0x0100.\n</span><span id=\"__span-8-155\"><a id=\"__codelineno-8-155\" name=\"__codelineno-8-155\" href=\"#__codelineno-8-155\"></a>  Standard Timings: Use 0x0101 as the invalid Standard Timings code, not 0x0100.\n</span><span id=\"__span-8-156\"><a id=\"__codelineno-8-156\" name=\"__codelineno-8-156\" href=\"#__codelineno-8-156\"></a>  Standard Timings: Use 0x0101 as the invalid Standard Timings code, not 0x0100.\n</span><span id=\"__span-8-157\"><a id=\"__codelineno-8-157\" name=\"__codelineno-8-157\" href=\"#__codelineno-8-157\"></a>  Standard Timings: Use 0x0101 as the invalid Standard Timings code, not 0x0100.\n</span><span id=\"__span-8-158\"><a id=\"__codelineno-8-158\" name=\"__codelineno-8-158\" href=\"#__codelineno-8-158\"></a>  Detailed Timing Descriptor #1: Mismatch of image size 708x398 mm vs display size 600x340 mm.\n</span><span id=\"__span-8-159\"><a id=\"__codelineno-8-159\" name=\"__codelineno-8-159\" href=\"#__codelineno-8-159\"></a>Block 1, CTA-861 Extension Block:\n</span><span id=\"__span-8-160\"><a id=\"__codelineno-8-160\" name=\"__codelineno-8-160\" href=\"#__codelineno-8-160\"></a>  Detailed Timing Descriptor #3: Mismatch of image size 944x531 mm vs display size 600x340 mm.\n</span><span id=\"__span-8-161\"><a id=\"__codelineno-8-161\" name=\"__codelineno-8-161\" href=\"#__codelineno-8-161\"></a>  Detailed Timing Descriptor #4: Mismatch of image size 944x531 mm vs display size 600x340 mm.\n</span><span id=\"__span-8-162\"><a id=\"__codelineno-8-162\" name=\"__codelineno-8-162\" href=\"#__codelineno-8-162\"></a>  Detailed Timing Descriptor #5: Mismatch of image size 944x513 mm vs display size 600x340 mm.\n</span><span id=\"__span-8-163\"><a id=\"__codelineno-8-163\" name=\"__codelineno-8-163\" href=\"#__codelineno-8-163\"></a>  Required 640x480p60 timings are missing in the established timings and the SVD list (VIC 1).\n</span><span id=\"__span-8-164\"><a id=\"__codelineno-8-164\" name=\"__codelineno-8-164\" href=\"#__codelineno-8-164\"></a>  HDMI VIC Codes must have their CTA-861 VIC equivalents in the VSB.\n</span><span id=\"__span-8-165\"><a id=\"__codelineno-8-165\" name=\"__codelineno-8-165\" href=\"#__codelineno-8-165\"></a>  Missing VCDB, needed for Set Selectable RGB Quantization to avoid interop issues.\n</span><span id=\"__span-8-166\"><a id=\"__codelineno-8-166\" name=\"__codelineno-8-166\" href=\"#__codelineno-8-166\"></a>EDID:\n</span><span id=\"__span-8-167\"><a id=\"__codelineno-8-167\" name=\"__codelineno-8-167\" href=\"#__codelineno-8-167\"></a>  Base EDID: Some timings are out of range of the Monitor Ranges:\n</span><span id=\"__span-8-168\"><a id=\"__codelineno-8-168\" name=\"__codelineno-8-168\" href=\"#__codelineno-8-168\"></a>    Vertical Freq: 24.000 - 144.000 Hz (Monitor: 24.000 - 80.000 Hz)\n</span><span id=\"__span-8-169\"><a id=\"__codelineno-8-169\" name=\"__codelineno-8-169\" href=\"#__codelineno-8-169\"></a>    Horizontal Freq: 18.000 - 108.000 kHz (Monitor: 30.000 - 100.000 kHz)\n</span><span id=\"__span-8-170\"><a id=\"__codelineno-8-170\" name=\"__codelineno-8-170\" href=\"#__codelineno-8-170\"></a>  CTA-861: Native progressive timings are a mix of several resolutions.\n</span><span id=\"__span-8-171\"><a id=\"__codelineno-8-171\" name=\"__codelineno-8-171\" href=\"#__codelineno-8-171\"></a>\n</span><span id=\"__span-8-172\"><a id=\"__codelineno-8-172\" name=\"__codelineno-8-172\" href=\"#__codelineno-8-172\"></a>EDID conformity: FAIL\n</span></code></pre></div>\n<p>也就是说，它的 4K 60Hz 从输入侧已经是 YCbCr 4:2:0 了，也就是每 2x2 的四个像素里，有四个 Y，一个 Cb 和一个 Cr。这样平均下来，8-bit 深度下每个像素的空间是 <span class=\"arithmatex\">\\((4*8+8+8)/4 = 12\\)</span> bit。如果是 4:2:2 的话，每 2x2 的四个像素里，有四个 Y，两个 Cb 和两个 Cr，平均下来，8-bit 深度下每个像素的空间是 <span class=\"arithmatex\">\\((4*8+2*8+2*8)/4 = 16\\)</span> bit。如果直接保存 RGB 4:4:4，8-bit 深度下就是 <span class=\"arithmatex\">\\(3*8=24\\)</span> bit。</p>\n<p>8-bit 深度下，不同的格式对比如下：</p>\n<table>\n<thead>\n<tr>\n<th>格式</th>\n<th>每像素空间</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>RGB 4:4:4</td>\n<td>24 bit</td>\n</tr>\n<tr>\n<td>YCbCr 4:4:4</td>\n<td>24 bit</td>\n</tr>\n<tr>\n<td>YCbCr 4:2:2</td>\n<td>16 bit</td>\n</tr>\n<tr>\n<td>YCbCr 4:2:0</td>\n<td>12 bit</td>\n</tr>\n</tbody>\n</table>\n<p>4K 30Hz 8-bit 4:4:4 下，传输需要的速率至少是 <span class=\"arithmatex\">\\(3840*2160*24*30=5.97 \\mathrm{Gbps}\\)</span>，还要考虑消隐区的开销。到 4K 60Hz 8-bit 4:4:4，传输速率 <span class=\"arithmatex\">\\(3840*2160*24*60=11.94 \\mathrm{Gbps}\\)</span> 就超过了 HDMI 1.4，要么用 HDMI 2.0 传，要么就改成 4K 60Hz 8-bit 4:2:0，传输速率是 <span class=\"arithmatex\">\\(3840*2160*12*60=5.97 \\mathrm{Gbps}\\)</span>。</p>\n<p>ffprobe 输出的 yuv420p 对应 YCbCr 4:2:0，tv 代表 limited range（16-235），bt709 代表颜色空间。</p>","date_modified":"2026-09-12T00:00:00+00:00","date_published":"2026-09-12T00:00:00+00:00","id":"https://jia.je/hardware/2026/09/12/fix-ugreen-95348/","image":null,"tags":["capture","hardware","hdmi","ugreen"],"title":"修复绿联 UG307-95348 HDMI 采集卡清晰度与颜色问题","url":"https://jia.je/hardware/2026/09/12/fix-ugreen-95348/"},{"authors":[],"content_html":"<h1 id=\"清华教室的音视频路由\">清华教室的音视频路由</h1>\n<h2 id=\"背景\">背景</h2>\n<p>最近在设计上课所用设备的音视频路由，借此机会梳理一下教室里现有的音视频路由，并记录一种可行的方案。</p>\n<!-- more -->\n\n<h2 id=\"教室环境\">教室环境</h2>\n<p>教室里原有的音视频路由大致如下。先看信号源：</p>\n<ul>\n<li>一体机的视频和音频输出</li>\n<li>通过 HDMI 接入的笔记本视频和音频输出</li>\n<li>话筒的音频输出</li>\n<li>教室里的摄像头，通常包括板书、近景、远景、学生视角等机位</li>\n</ul>\n<p>这些信号经过一个可在讲台上操控的导播台（下称「讲台」，实际设备未必位于讲台内部），可以输出到以下位置：</p>\n<ul>\n<li>教室的音响</li>\n<li>投影、返显以及学生头顶的显示器</li>\n<li>一体机的音视频输入</li>\n<li>通过 USB 接入的笔记本音视频输入</li>\n</ul>\n<p>画成路由图大致如下。视频部分：</p>\n<pre class=\"mermaid\"><code>flowchart TD\n    笔记本显示输出 --&gt;|HDMI| 讲台1[讲台]\n    一体机显示输出 --&gt; 讲台1\n    教室摄像头 --&gt; 讲台1\n    教室摄像头 --&gt; 讲台2[讲台]\n\n    讲台1 --&gt; 投影\n    讲台1 --&gt; 返显\n    讲台1 --&gt; 显示器\n    讲台2 --&gt; 一体机视频输入\n    讲台2 --&gt;|USB| 笔记本视频输入</code></pre>\n<p>音频部分：</p>\n<pre class=\"mermaid\"><code>flowchart TD\n    笔记本音频输出 --&gt;|HDMI| 讲台\n    一体机音频输出 --&gt; 讲台\n    话筒 --&gt; 讲台\n\n    讲台 --&gt; 音响\n\n    话筒 --&gt; 讲台1[讲台]\n    讲台1 --&gt; 一体机音频输入\n    讲台1 --&gt;|USB| 笔记本音频输入</code></pre>\n<h2 id=\"针对上课需求的设计\">针对上课需求的设计</h2>\n<p>回到我的课程。我希望能在多个信号源之间方便地切换，包括 Mac 笔记本、鸿蒙电脑以及一台便携摄像头。讲台自带的导播功能不足以支撑这么复杂的切换，手上又没有 ATEM Mini 导播台（怀念以前学生节的日子），于是打算在 Mac 笔记本上用 <a href=\"https://obsproject.com/\">OBS</a> 做软件导播。</p>\n<p>那么音视频路由该如何设计？下面是我最终采用的路由方式。视频部分：</p>\n<pre class=\"mermaid\"><code>flowchart TD\n    鸿蒙电脑 --&gt;|HDMI| 采集卡\n    采集卡 --&gt;|Type-C| Mac电脑\n    便携摄像头 --&gt;|USB| Mac电脑\n    Mac电脑 --&gt;|HDMI| 讲台\n    Mac电脑 --&gt; OBS直播或录像\n    教室摄像头 --&gt; 讲台1[讲台]\n    讲台 --&gt; 投影\n    讲台 --&gt; 返显\n    讲台 --&gt; 显示器\n    讲台1 --&gt;|USB| Mac电脑</code></pre>\n<p>音频部分：</p>\n<pre class=\"mermaid\"><code>flowchart TD\n    鸿蒙电脑 --&gt;|HDMI| 采集卡\n    采集卡 --&gt;|Type-C| Mac电脑\n    便携摄像头 --&gt;|USB| Mac电脑\n    Mac电脑 --&gt;|HDMI| 讲台\n    Mac电脑 --&gt; OBS直播或录像\n    话筒 --&gt; 讲台\n    话筒 --&gt; 讲台1[讲台]\n    讲台 --&gt; 音响\n    讲台1 --&gt;|USB| Mac电脑</code></pre>\n<p>这样，Mac 上的 OBS 就能获得来自鸿蒙电脑、Mac 自身屏幕、教室摄像头和话筒的音视频输入；再通过 OBS 的 Projector 把画面输出到扩展屏，经由讲台投到教室的各种投影和显示器上，音频则从音响放出来。之后要录像或直播，直接使用 OBS 自带的功能即可。</p>\n<p>针对上课 4K 30 FPS 但是静态为主的场景，在 OBS 设置里，Output 选择 Simple，Video Bitrate 选 8000 Kbps，Video Encoder 选 Hardware (Apple, H.264)，下面 Recording Quality 选 Same as stream，Recording Format 选 Matroska Video (.mkv)。</p>\n<p>可以打开 OBS 的 View -&gt; Stats，看看实时码率，有没有 missed or skipped frame。</p>\n<h3 id=\"基于-hdmi-分配器的候选方案\">基于 HDMI 分配器的候选方案</h3>\n<p>另一个候选方案是使用 HDMI 分配器：把展示用的鸿蒙电脑信号一分为二，一份直连讲台投出，另一份经采集卡进入 Mac 电脑的 OBS。此时视频拓扑变为：</p>\n<pre class=\"mermaid\"><code>flowchart TD\n    鸿蒙电脑 --&gt;|HDMI| 分配器[HDMI分配器]\n    分配器 --&gt;|HDMI| 采集卡\n    采集卡 --&gt;|Type-C| Mac电脑\n    便携摄像头 --&gt;|USB| Mac电脑\n    分配器 --&gt;|HDMI| 讲台\n    Mac电脑 --&gt; OBS直播或录像\n    教室摄像头 --&gt; 讲台1[讲台]\n    讲台 --&gt; 投影\n    讲台 --&gt; 返显\n    讲台 --&gt; 显示器\n    讲台1 --&gt;|USB| Mac电脑</code></pre>\n<p>这种设计把 OBS 放到了旁路，避开了采集卡可能出现的一些问题（后文会提到）；缺点是投出来的内容只能来自鸿蒙电脑，无法通过 OBS 二次加工。</p>\n<h2 id=\"设备选型\">设备选型</h2>\n<p>采集卡用的是绿联的 <a href=\"https://www.lulian.cn/product/1537.html\">UG307-95348 4K60Hz MS2130S 视频采集卡</a>，USB 名称是 UGREEN 95348，VID 0x2b89，PID 0x5348。</p>\n<p>便携摄像头用的是：</p>\n<ul>\n<li>绿联 <a href=\"https://www.lulian.cn/product/1815.html\">CM717-25442 2K USB 400W 像素摄像头</a>，USB 名称是 UGREEN Camera 2K，VID 0x0c45，PID 0x636f；</li>\n<li>绿联 CM831-65381 4K USB 800W 像素摄像头，USB 名称是 UGREEN Camera 4K，VID 0xeba4，PID 0x6579。</li>\n</ul>\n<p>HDMI 分配器用的是绿联的 <a href=\"https://www.lulian.cn/product/1527.html\">AP502-55493 4K60Hz 一进二出 HDMI 分配器</a>，输入规格为 5V/1A，支持一路 HDMI 输入、两路 HDMI 输出。从 EDID 来看，采用的是 <a href=\"https://www.ite.com.tw/tw/product/cate1/IT6664\">IT6664</a> 方案，可以通过拨码开关切换不同的模式：</p>\n<ul>\n<li>1 上 2 上（默认）：当两路输出都接上时，输入侧看到的 EDID 由两路输出的 EDID 共同决定，设备显示 ITE-6664；只接一路输出时，输入侧直接透传该路的 EDID</li>\n<li>1 上 2 下：强制 1080P60Hz，设备显示 UGREEN-FHD</li>\n<li>1 下 2 上：强制 4K60Hz，设备显示 UGREEN-UHD</li>\n<li>1 下 2 下：复制 OUT1 设备的 EDID，如果没有 OUT1，则 fallback 到 1080P60Hz</li>\n</ul>\n<p>仅供参考，不构成购买建议。</p>\n<h2 id=\"遇到的实际问题\">遇到的实际问题</h2>\n<p>在使用绿联 UG307-95348 采集卡的过程中，还遇到并修复了一些清晰度和颜色问题，具体方法见 <a href=\"../../../../../hardware/2026/09/12/fix-ugreen-95348/\">修复绿联 UG307-95348 HDMI 采集卡清晰度与颜色问题</a>。</p>\n<p>在使用绿联 AP502-55493 HDMI 分配器的过程中，也遇到了一些显示问题：在特定教室里，在默认的 1 上 2 上配置（自动计算 EDID）下，两路输出只有一路可以正常显示，比如 OUT1 接教室的投影是正常的，OUT2 接采集卡就黑屏。调整成 1 下 2 下，即复制 OUT1 设备的 EDID，把 OUT1 接教室的投影，把 OUT2 接上面的采集卡，这两路又都能正常工作。初步怀疑和 EDID 有关系，后续考虑把两路输出的 EDID 导出来对比一下，也看看 HDMI 分配器给输入侧暴露的 EDID 是怎么样的。目前抓取了一下输出侧的 EDID，有问题的教室的投影，最高支持 4K 60Hz 4:4:4，而采集卡和没问题的教室的投影，最高只支持 4K 60Hz 4:2:0，怀疑和这个有关。</p>\n<p>音频方面也踩到了一些坑，而且都和立体声有关。</p>\n<p>第一个坑：某个教室录出来的音频虽然标称双声道，但实际上只有左声道有声音，右声道几乎静音。</p>\n<p><img alt=\"右声道无声\" src=\"../../../../classroom-routing-no-right.png\" /></p>\n<p>第二个坑：另一个教室录出来的音频同样是双声道，但右声道是左声道的反相，两个声道一旦叠加就会互相抵消。</p>\n<p><img alt=\"左右声道反相\" src=\"../../../../classroom-routing-invert.png\" /></p>\n<p>上面两张图都是用 <a href=\"../../../../stereo_check.py\">stereo_check.py</a> 绘制的。</p>\n<p>和教室管理员沟通后发现，第二个坑对应的教室在更换 HDMI 线之后，现象就变得和第一个坑一样了，即只有左声道有声音、右声道静音。不过背后的原理，目前还没搞清楚。</p>\n<p>此外，上课途中还遇到过突发情况：采集卡采集的视频出现闪屏和黑屏，不确定是采集卡的问题还是 HDMI 线的问题。下课后又无法复现，不知道是否和温度有关。</p>\n<h2 id=\"常用工具\">常用工具</h2>\n<p>ffmpeg 常用命令行：</p>\n<div class=\"language-shell highlight\"><pre><span></span><code><span id=\"__span-0-1\"><a id=\"__codelineno-0-1\" name=\"__codelineno-0-1\" href=\"#__codelineno-0-1\"></a><span class=\"c1\"># 截取视频中的一帧</span>\n</span><span id=\"__span-0-2\"><a id=\"__codelineno-0-2\" name=\"__codelineno-0-2\" href=\"#__codelineno-0-2\"></a>ffmpeg<span class=\"w\"> </span>-i<span class=\"w\"> </span>source.mp4<span class=\"w\"> </span>-ss<span class=\"w\"> </span>hh:mm:ss.xxx<span class=\"w\"> </span>-frames:v<span class=\"w\"> </span><span class=\"m\">1</span><span class=\"w\"> </span>output.png\n</span><span id=\"__span-0-3\"><a id=\"__codelineno-0-3\" name=\"__codelineno-0-3\" href=\"#__codelineno-0-3\"></a><span class=\"c1\"># 截取视频中的一部分，以左上角为坐标原点，x 轴向右，y 轴向下，从 (x,y) 到 (x+w, y+h)</span>\n</span><span id=\"__span-0-4\"><a id=\"__codelineno-0-4\" name=\"__codelineno-0-4\" href=\"#__codelineno-0-4\"></a><span class=\"c1\"># 用 https://ffmpeg.party/tools/cropper/ 辅助确定坐标</span>\n</span><span id=\"__span-0-5\"><a id=\"__codelineno-0-5\" name=\"__codelineno-0-5\" href=\"#__codelineno-0-5\"></a>ffmpeg<span class=\"w\"> </span>-i<span class=\"w\"> </span>source.mp4<span class=\"w\"> </span>-vf<span class=\"w\"> </span><span class=\"s2\">\"crop=w:h:x:y\"</span><span class=\"w\"> </span>output.mp4\n</span><span id=\"__span-0-6\"><a id=\"__codelineno-0-6\" name=\"__codelineno-0-6\" href=\"#__codelineno-0-6\"></a><span class=\"c1\"># 原样保留视频</span>\n</span><span id=\"__span-0-7\"><a id=\"__codelineno-0-7\" name=\"__codelineno-0-7\" href=\"#__codelineno-0-7\"></a>ffmpeg<span class=\"w\"> </span>-i<span class=\"w\"> </span>source.mp4<span class=\"w\"> </span>-c:v<span class=\"w\"> </span>copy<span class=\"w\"> </span>output.mp4\n</span><span id=\"__span-0-8\"><a id=\"__codelineno-0-8\" name=\"__codelineno-0-8\" href=\"#__codelineno-0-8\"></a><span class=\"c1\"># 标准化视频中音频的响度</span>\n</span><span id=\"__span-0-9\"><a id=\"__codelineno-0-9\" name=\"__codelineno-0-9\" href=\"#__codelineno-0-9\"></a>ffmpeg<span class=\"w\"> </span>-i<span class=\"w\"> </span>source.mp4<span class=\"w\"> </span>-af<span class=\"w\"> </span><span class=\"s2\">\"loudnorm=I=-16:TP=-1.5:LRA=11\"</span><span class=\"w\"> </span>output.mp4\n</span><span id=\"__span-0-10\"><a id=\"__codelineno-0-10\" name=\"__codelineno-0-10\" href=\"#__codelineno-0-10\"></a><span class=\"c1\"># 只保留双声道里的左声道</span>\n</span><span id=\"__span-0-11\"><a id=\"__codelineno-0-11\" name=\"__codelineno-0-11\" href=\"#__codelineno-0-11\"></a>ffmpeg<span class=\"w\"> </span>-i<span class=\"w\"> </span>source.mp4<span class=\"w\"> </span>-af<span class=\"w\"> </span><span class=\"s2\">\"pan=mono|c0=c0\"</span><span class=\"w\"> </span>output.mp4\n</span><span id=\"__span-0-12\"><a id=\"__codelineno-0-12\" name=\"__codelineno-0-12\" href=\"#__codelineno-0-12\"></a><span class=\"c1\"># 只保留左声道的同时，标准化音频响度</span>\n</span><span id=\"__span-0-13\"><a id=\"__codelineno-0-13\" name=\"__codelineno-0-13\" href=\"#__codelineno-0-13\"></a>ffmpeg<span class=\"w\"> </span>-i<span class=\"w\"> </span>source.mp4<span class=\"w\"> </span>-af<span class=\"w\"> </span><span class=\"s2\">\"pan=mono|c0=c0,loudnorm=I=-16:dual_mono=true:TP=-1.5:LRA=11:print_format=summary\"</span><span class=\"w\"> </span>-ar<span class=\"w\"> </span>48k<span class=\"w\"> </span>output.mp4\n</span><span id=\"__span-0-14\"><a id=\"__codelineno-0-14\" name=\"__codelineno-0-14\" href=\"#__codelineno-0-14\"></a><span class=\"c1\"># 只保留左声道，标准化音频响度，重新用 libx264 CRF 22 编码</span>\n</span><span id=\"__span-0-15\"><a id=\"__codelineno-0-15\" name=\"__codelineno-0-15\" href=\"#__codelineno-0-15\"></a>ffmpeg<span class=\"w\"> </span>-i<span class=\"w\"> </span>source.mp4<span class=\"w\"> </span>-c:v<span class=\"w\"> </span>libx264<span class=\"w\"> </span>-preset<span class=\"w\"> </span>slow<span class=\"w\"> </span>-crf<span class=\"w\"> </span><span class=\"m\">22</span><span class=\"w\"> </span>-af<span class=\"w\"> </span><span class=\"s2\">\"pan=mono|c0=c0,loudnorm=I=-16:dual_mono=true:TP=-1.5:LRA=11:print_format=summary\"</span><span class=\"w\"> </span>-ar<span class=\"w\"> </span>48k<span class=\"w\"> </span>output.mp4\n</span><span id=\"__span-0-16\"><a id=\"__codelineno-0-16\" name=\"__codelineno-0-16\" href=\"#__codelineno-0-16\"></a><span class=\"c1\"># 拼接两个输入视频，只保留左声道，标准化音频响度，重新用 libx264 CRF 22 编码</span>\n</span><span id=\"__span-0-17\"><a id=\"__codelineno-0-17\" name=\"__codelineno-0-17\" href=\"#__codelineno-0-17\"></a>ffmpeg<span class=\"w\"> </span>-i<span class=\"w\"> </span>source1.mp4<span class=\"w\"> </span>-i<span class=\"w\"> </span>source4.mp4<span class=\"w\"> </span>-filter_complex<span class=\"w\"> </span><span class=\"s2\">\"[0:v:0][0:a:0][1:v:0][1:a:0]concat=n=2:v=1:a=1[outv][outa]; [outa]pan=mono|c0=c0,loudnorm=I=-16:dual_mono=true:TP=-1.5:LRA=11:print_format=summary[outa_final]\"</span><span class=\"w\"> </span>-map<span class=\"w\"> </span><span class=\"s2\">\"[outv]\"</span><span class=\"w\"> </span>-map<span class=\"w\"> </span><span class=\"s2\">\"[outa_final]\"</span><span class=\"w\"> </span>-c:v<span class=\"w\"> </span>libx264<span class=\"w\"> </span>-preset<span class=\"w\"> </span>slow<span class=\"w\"> </span>-crf<span class=\"w\"> </span><span class=\"m\">22</span><span class=\"w\"> </span>-ar<span class=\"w\"> </span><span class=\"m\">48000</span><span class=\"w\"> </span>output.mp4\n</span><span id=\"__span-0-18\"><a id=\"__codelineno-0-18\" name=\"__codelineno-0-18\" href=\"#__codelineno-0-18\"></a><span class=\"c1\"># 原样保留音频</span>\n</span><span id=\"__span-0-19\"><a id=\"__codelineno-0-19\" name=\"__codelineno-0-19\" href=\"#__codelineno-0-19\"></a>ffmpeg<span class=\"w\"> </span>-i<span class=\"w\"> </span>source.mp4<span class=\"w\"> </span>-c:a<span class=\"w\"> </span>copy<span class=\"w\"> </span>output.mp4\n</span><span id=\"__span-0-20\"><a id=\"__codelineno-0-20\" name=\"__codelineno-0-20\" href=\"#__codelineno-0-20\"></a><span class=\"c1\"># 测量前 10s 的音量大小</span>\n</span><span id=\"__span-0-21\"><a id=\"__codelineno-0-21\" name=\"__codelineno-0-21\" href=\"#__codelineno-0-21\"></a>ffmpeg<span class=\"w\"> </span>-i<span class=\"w\"> </span>source.mp4<span class=\"w\"> </span>-af<span class=\"w\"> </span><span class=\"s2\">\"volumedetect\"</span><span class=\"w\"> </span>-f<span class=\"w\"> </span>null<span class=\"w\"> </span>-t<span class=\"w\"> </span><span class=\"m\">10</span><span class=\"w\"> </span>-\n</span></code></pre></div>\n<p>LosslessCut：以关键帧的粒度，快速剪辑</p>","date_modified":"2026-09-11T00:00:00+00:00","date_published":"2026-09-11T00:00:00+00:00","id":"https://jia.je/misc/2026/09/11/classroom-routing/","image":null,"tags":["class","education","misc","tsinghua"],"title":"清华教室的音视频路由","url":"https://jia.je/misc/2026/09/11/classroom-routing/"},{"authors":[],"content_html":"<h1 id=\"第一个教师节随想\">第一个教师节随想</h1>\n<h2 id=\"背景\">背景</h2>\n<p>今天是我博士毕业、入职博士后以来度过的第一个教师节（博士后也算老师对不对，doge）。借着这个由头，随便写点感想。</p>\n<!-- more -->\n\n<h2 id=\"从助教到老师\">从助教到老师</h2>\n<p>入职之后，终于开始真正忙起了各种教学工作：小学期的课程要上，秋季学期的事情要筹备，各种事务也在慢慢走上正轨。</p>\n<p>回想 2019 年，那时我刚做本科助教。作为学生，我总觉得课内的一些知识没能很好地跟上时代，于是便以助教的身份投入到教学改革中。后来计算机系一路扩招、培养方案不断调整，很多课程里都留下了我的足迹。熬了这么多年，终于博士毕业，拿到了在大学里当老师的入场券。当年保研时选择直博，其实就是为了这一天。不然我可能本科毕业就直接去工作了。</p>\n<p>当然，博士生活以发论文、做科研为主，过得并不算特别开心：我喜欢研究新东西，却不喜欢发论文。好在做科研之余，还能尽量投身我所热爱的本科教学，所以整体也还过得去。这些年，看着一门门课程不断改善，发布课程文档，做各种课程调整，培养一代又一代助教，再一届一届地组织助教培训。确实做了不少事。这些东西在世人眼中也许并不那么重要，但我心里很有自豪感。</p>\n<h2 id=\"身份在变代沟也有了\">身份在变，代沟也有了</h2>\n<p>转眼本科入学已经 9 年，明年入学的新生，就要整整比我小 10 岁了。</p>\n<p>有时我也觉得，自己的身份正从学生变成助教、再变成老师；很多东西都在变化，代沟慢慢出现，和低年级同学之间的纽带也在逐渐减少。当年我熟悉、认识的那些人，大多也要毕业或即将毕业了。我一直在努力避免这道沟，尝试跟上年轻人的潮流。虽然我还不到 30 岁，但这个趋势似乎不可避免。</p>\n<p>所以今年我也想突破一下自我，去做一些年轻人更喜闻乐见的东西，把 B 站和小红书捡起来；也在认真考虑要不要去抖音开个账号，尽量接地气一些。</p>\n<h2 id=\"小学期-rust-课的一次尝试\">小学期 Rust 课的一次尝试</h2>\n<p>最近忙着做课程的进一步改革。AI 时代来了，各课程老师对“课该怎么讲”有很深的担忧，也有很强的改变意愿（看过我之前<a href=\"../../../04/12/ai-era-cs-education/\">博客</a>的话应该知道），所以我也在积极做一些尝试。</p>\n<p>今天正好是我们 <a href=\"https://lab.cs.tsinghua.edu.cn/rust/\">Rust 课程</a> 小学期的最后一堂课。今年这门课我们做了一个比较大胆的尝试，让大家做半开放的选题：自己选，用 Agent 协助完成整个编程，最后做一次展示。今天上午就是最后的展示。</p>\n<p>从整体效果看，我觉得挺好。同学们确实做出了很多很漂亮的东西，它们可以走出课程本身，被更多人持续使用，也有可能慢慢长成一个知名的开源项目。当然这只是第一次尝试，后面还有很多课程，我想和各位老师、助教一起研究，怎么在这个时代找到能够培养大家新时代所需能力的方法，同时让大家学得好、也学得快乐，这是接下来主要的努力方向。</p>\n<h2 id=\"所有人都该学会用-ai\">所有人都该学会用 AI</h2>\n<p>我们确实面对很多困难，但今天是教师节，我也不想谈太多困难。很多事情，就是在实践中慢慢把它干好。我也不必想太多。在这个时代，谁也不知道计算机教育该怎么走，谁也不知道正确答案。无论是你、是我，还是他，都在摸索；而这种摸索，可能很难在短时间内看到成果，甚至过两年就过时了，又会出现新的潮流，需要做更新的调整。计算机教育大概就是这样，这个时代大概也是这样：所有人都得跟着时代一直跑，一直改。</p>\n<p>但我并不害怕，也愿意面对这些挑战，去“整一整”，反正整多少是多少，也不知道整成什么样，只希望能尽自己的一份绵薄之力，为中国的本科教育做一点贡献。接下来这一年，我想在有限的时间里尽量多做一些尝试，和大家一起探索计算机教育的未来：从基础课开始，从计算机系本系的专业课，到给外系开的专业课，各方面都试一试。</p>\n<p>我越来越觉得，以后计算机一定会像数学一样，成为所有人都该学会使用的专业或技能。其中比较重要的一点，就是 AI 的使用。这一定是所有人都可以、也一定要学会的，然后把它应用到自己的领域里去，不一定是计算机，什么领域都可以。这既是趋势，也是我们教育者要努力促成的事。</p>\n<h2 id=\"ai-入门\">AI 入门</h2>\n<p>今天的课程展示结束后，裴老师点评时说，他感到很受鼓舞：在 AI 的加持下，同学们确实能做出很多以往会觉得大一学生很难做到的东西。这也让他对自己教的软件工程课程未来的改革更有信心了。</p>\n<p>我也在想，本系的同学能做到这个程度，那么给外系的同学稍微降低一点难度，未尝不可。而且这些东西有很强的实际意义，可以放到各行各业、各门各类中去用。所以真的有可能，所有人都能写自己的 AI 工具，针对自己所在行业的各种需求，用 AI 去做各种东西，无论是编程，还是别的什么。这也是我们 <a href=\"https://edu.cs.tsinghua.edu.cn/cca/\">计算机文化基础</a> 课想要努力达成的效果。当然，这门课最早的时候确实是教 Office 的，但现在更多内容要往 AI 上转。</p>\n<h2 id=\"编程课怎么改\">编程课怎么改</h2>\n<p>除了这种零基础的 AI 入门或计算机入门课，编程课怎么改也是一个很重要的点。大家都知道，编程本身的需求肯定在减少。但编程课该学多少、怎么学，要不要和后面的数据结构、软件工程等内容做一些融合，再用 AI 去做更多编程上的尝试，这些都是未来要去探索的地方，也是目前受冲击比较大的地方。</p>\n<p>不过，想归想，还是要不断地做。希望借着这两年时间，能逐渐形成一条比较清晰的思想脉络，去指导未来的教学，让它朝着同学们喜闻乐见、导师们招到想要的学生、同时也能给企业和国家培养出合格人才的方向走。</p>\n<h2 id=\"写在最后\">写在最后</h2>\n<p>这篇随想写得很随意，想到哪说到哪，没有什么特别的组织，也没有一定要表达的主题，只是简单总结一下最近看到的、想到的一些事情。</p>\n<p>最后，希望读者在这个时代也能找到适合自己的 AI 使用方式，不要焦虑，能找到自己喜欢做、想做的事情。</p>","date_modified":"2026-09-10T00:00:00+00:00","date_published":"2026-09-10T00:00:00+00:00","id":"https://jia.je/misc/2026/09/10/first-teachers-day/","image":null,"tags":["dcst","education","misc","postdoc"],"title":"第一个教师节随想","url":"https://jia.je/misc/2026/09/10/first-teachers-day/"},{"authors":[],"content_html":"<h1 id=\"记录一次在-macos-上与微软雅黑字体的搏斗\">记录一次在 macOS 上与微软雅黑字体的搏斗</h1>\n<h2 id=\"背景\">背景</h2>\n<p>最近在做 PPT，用了一个在 Windows 上制作的 PPT 模板，它用到了 <code>微软雅黑 Light</code> 字体，在 macOS 上显示不正常，因此做了一些细致的研究和排查，找到了原因和解决方案。</p>\n<!-- more -->\n\n<h2 id=\"搏斗过程\">搏斗过程</h2>\n<p>遇到的问题是这样的：在 macOS 上做了一个 PPT，放到 Windows 或者鸿蒙的 WPS 上显示，发现字体渲染并不一致。如果在 macOS 上保存 PPT 的时候选择内嵌字体，它也会提示“微软雅黑 Light”字体不存在。说明 macOS 上并没有找到正确的字体，fallback 到了其他字体来显示。然后在 Windows 上找到了正确的字体，导致了效果的不同。</p>\n<p>但实际上，macOS 上的 Office，是附带了微软雅黑的字体文件的：</p>\n<div class=\"language-shell highlight\"><pre><span></span><code><span id=\"__span-0-1\"><a id=\"__codelineno-0-1\" name=\"__codelineno-0-1\" href=\"#__codelineno-0-1\"></a>&gt;<span class=\"w\"> </span>ls<span class=\"w\"> </span>/Applications/Microsoft<span class=\"se\">\\ </span>PowerPoint.app/Contents/Resources/DFonts/msyh*.ttc\n</span><span id=\"__span-0-2\"><a id=\"__codelineno-0-2\" name=\"__codelineno-0-2\" href=\"#__codelineno-0-2\"></a><span class=\"s1\">'/Applications/Microsoft PowerPoint.app/Contents/Resources/DFonts/msyh.ttc'</span>*\n</span><span id=\"__span-0-3\"><a id=\"__codelineno-0-3\" name=\"__codelineno-0-3\" href=\"#__codelineno-0-3\"></a><span class=\"s1\">'/Applications/Microsoft PowerPoint.app/Contents/Resources/DFonts/msyhbd.ttc'</span>*\n</span><span id=\"__span-0-4\"><a id=\"__codelineno-0-4\" name=\"__codelineno-0-4\" href=\"#__codelineno-0-4\"></a><span class=\"s1\">'/Applications/Microsoft PowerPoint.app/Contents/Resources/DFonts/msyhl.ttc'</span>*\n</span></code></pre></div>\n<p>对应了微软雅黑的不同的字重，其中 msyhl 就是对应了 Light。也就是说，虽然 macOS 没有字体，但 PowerPoint 自带了，理应正常支持。</p>\n<p>然后，用 Python 探索了一下这些字体里的各种信息，发现了一些端倪：</p>\n<div class=\"language-text highlight\"><pre><span></span><code><span id=\"__span-1-1\"><a id=\"__codelineno-1-1\" name=\"__codelineno-1-1\" href=\"#__codelineno-1-1\"></a>────────────────────────────────────────────────────────────────────────────────────────────────────────────\n</span><span id=\"__span-1-2\"><a id=\"__codelineno-1-2\" name=\"__codelineno-1-2\" href=\"#__codelineno-1-2\"></a>■ face #1/2   Microsoft YaHei Light / Regular / MicrosoftYaHeiLight\n</span><span id=\"__span-1-3\"><a id=\"__codelineno-1-3\" name=\"__codelineno-1-3\" href=\"#__codelineno-1-3\"></a>────────────────────────────────────────────────────────────────────────────────────────────────────────────\n</span><span id=\"__span-1-4\"><a id=\"__codelineno-1-4\" name=\"__codelineno-1-4\" href=\"#__codelineno-1-4\"></a>  #   platform   enc language         nameID 含义                 len   off    文本\n</span><span id=\"__span-1-5\"><a id=\"__codelineno-1-5\" name=\"__codelineno-1-5\" href=\"#__codelineno-1-5\"></a>  1   Windows(3) 1   英文(en)         1      Family               42    250    Microsoft YaHei Light\n</span><span id=\"__span-1-6\"><a id=\"__codelineno-1-6\" name=\"__codelineno-1-6\" href=\"#__codelineno-1-6\"></a>  2   Windows(3) 1   英文(en)         2      Subfamily            14    292    Regular\n</span><span id=\"__span-1-7\"><a id=\"__codelineno-1-7\" name=\"__codelineno-1-7\" href=\"#__codelineno-1-7\"></a>  17  Windows(3) 1   简体中文(zh-Hans) 1      Family               20    2220   微软雅黑 Light\n</span><span id=\"__span-1-8\"><a id=\"__codelineno-1-8\" name=\"__codelineno-1-8\" href=\"#__codelineno-1-8\"></a>  18  Windows(3) 1   简体中文(zh-Hans) 2      Subfamily            14    292    Regular\n</span></code></pre></div>\n<p>这是微软雅黑 Light 的 name table，它的字体名称有英文和中文两个版本。如果我把字体改成 Microsoft YaHei Light，它就可以正常找到字体，说明我的英文 macOS 上的 PowerPoint 没有正确匹配字体的中文名。</p>\n<p>我做了一个测试的 PPT，三行字，第一行是微软雅黑 Light 字体，第二行是 Microsoft YaHei Light 字体，第三是 Microsoft YaHei UI 字体。能明显看出第一行字体有问题，和第三行一样，而第二行字体是正确的：</p>\n<p><img alt=\"\" src=\"../../../../battle-with-msyh-font-test.png\" /></p>\n<p>后两行正确匹配了字体，所以渲染没问题。而同样的文件，放到 Windows PowerPoint 里打开，可以看到正确的显示结果：</p>\n<p><img alt=\"\" src=\"../../../../battle-with-msyh-font-test-windows.png\" /></p>\n<p>前两个字体是同一个，和第三个不同，这是预期结果。</p>\n<p>因此最后的解决办法就是：把模板里的字体，从微软雅黑 Light，改成 Microsoft YaHei Light。这样就可以在 macOS 和 Windows 上都能正常显示了。</p>\n<p>至于鸿蒙 WPS 怎么办：从虚拟机 Windows 里复制 msyh*.ttc 字体，安装到鸿蒙里，就可以正常显示了。</p>","date_modified":"2026-09-10T00:00:00+00:00","date_published":"2026-09-10T00:00:00+00:00","id":"https://jia.je/software/2026/09/10/battle-with-msyh-font/","image":null,"tags":["font","macos","office","software","windows"],"title":"记录一次在 macOS 上与微软雅黑字体的搏斗","url":"https://jia.je/software/2026/09/10/battle-with-msyh-font/"},{"authors":[],"content_html":"<h1 id=\"记一次-windows-更新-0x800703f1-错误的修复\">记一次 Windows 更新 0x800703F1 错误的修复</h1>\n<h2 id=\"背景\">背景</h2>\n<p>最近在准备课堂展示，需要用到 Windows，于是翻出鸿蒙电脑，跑起了 Windows on ARM 虚拟机。结果 Windows 更新老是报 0x800703F1 错误，我做了不少自己都说不清的尝试，最后稀里糊涂地解决了。</p>\n<!-- more -->\n\n<h2 id=\"现象\">现象</h2>\n<p>现象是，Windows 更新界面里所有更新一律失败，统一报错 0x800703F1。上网搜了一圈，网上信息基本都指向注册表损坏，例如运行下面这条命令时同样会报错：</p>\n<div class=\"language-text highlight\"><pre><span></span><code><span id=\"__span-0-1\"><a id=\"__codelineno-0-1\" name=\"__codelineno-0-1\" href=\"#__codelineno-0-1\"></a>reg load HKLM\\COMPONENTS C:\\Windows\\System32\\config\\components\n</span></code></pre></div>\n<h2 id=\"失败的尝试\">失败的尝试</h2>\n<p>参考了网上的大量资料（<a href=\"https://gist.github.com/74Thirsty/18e2b9152c0ca3a2f5d76dcd1b5d6ff4\">[1]</a>、<a href=\"https://www.reddit.com/r/WindowsHelp/comments/1k6aktc/error_0x800703f1_code_how_to_fix/\">[2]</a>），各种方法都试了一遍，无一成功：</p>\n<ul>\n<li><code>sfc /scannow</code> 和 <code>DISM /Online /Cleanup-Image /RestoreHealth</code> 都跑过，修复时仍报同样的 0x800703F1 错误。</li>\n<li><code>sysnative component scanner</code> 跑了一段输出后就卡住不动，不知道在干什么。</li>\n<li>下载了新的 Windows 11 on ARM ISO，选择保留数据重装，结果还是报 0x800703F1。</li>\n</ul>\n<h2 id=\"成功的尝试\">成功的尝试</h2>\n<p>最后抱着试试看的心态，采用了 <a href=\"https://www.reddit.com/r/WindowsHelp/comments/1k6aktc/error_0x800703f1_code_how_to_fix/\">Reddit</a> 上这个方案：</p>\n<div class=\"language-text highlight\"><pre><span></span><code><span id=\"__span-1-1\"><a id=\"__codelineno-1-1\" name=\"__codelineno-1-1\" href=\"#__codelineno-1-1\"></a>-TekkieBoy-\n</span><span id=\"__span-1-2\"><a id=\"__codelineno-1-2\" name=\"__codelineno-1-2\" href=\"#__codelineno-1-2\"></a>\n</span><span id=\"__span-1-3\"><a id=\"__codelineno-1-3\" name=\"__codelineno-1-3\" href=\"#__codelineno-1-3\"></a>Hi,\n</span><span id=\"__span-1-4\"><a id=\"__codelineno-1-4\" name=\"__codelineno-1-4\" href=\"#__codelineno-1-4\"></a>\n</span><span id=\"__span-1-5\"><a id=\"__codelineno-1-5\" name=\"__codelineno-1-5\" href=\"#__codelineno-1-5\"></a>try the SequenceNumberChecker from there:\n</span><span id=\"__span-1-6\"><a id=\"__codelineno-1-6\" name=\"__codelineno-1-6\" href=\"#__codelineno-1-6\"></a>\n</span><span id=\"__span-1-7\"><a id=\"__codelineno-1-7\" name=\"__codelineno-1-7\" href=\"#__codelineno-1-7\"></a>https://github.com/MOV-EDX/SequenceNumberChecker/releases/tag/1.0.1\n</span><span id=\"__span-1-8\"><a id=\"__codelineno-1-8\" name=\"__codelineno-1-8\" href=\"#__codelineno-1-8\"></a>\n</span><span id=\"__span-1-9\"><a id=\"__codelineno-1-9\" name=\"__codelineno-1-9\" href=\"#__codelineno-1-9\"></a>Copy the drivers hive from the path:\n</span><span id=\"__span-1-10\"><a id=\"__codelineno-1-10\" name=\"__codelineno-1-10\" href=\"#__codelineno-1-10\"></a>\n</span><span id=\"__span-1-11\"><a id=\"__codelineno-1-11\" name=\"__codelineno-1-11\" href=\"#__codelineno-1-11\"></a>C:\\Windows\\System32\\config\n</span><span id=\"__span-1-12\"><a id=\"__codelineno-1-12\" name=\"__codelineno-1-12\" href=\"#__codelineno-1-12\"></a>\n</span><span id=\"__span-1-13\"><a id=\"__codelineno-1-13\" name=\"__codelineno-1-13\" href=\"#__codelineno-1-13\"></a>on your desktop.\n</span><span id=\"__span-1-14\"><a id=\"__codelineno-1-14\" name=\"__codelineno-1-14\" href=\"#__codelineno-1-14\"></a>\n</span><span id=\"__span-1-15\"><a id=\"__codelineno-1-15\" name=\"__codelineno-1-15\" href=\"#__codelineno-1-15\"></a>Create a copy from your drivers hive as backup and save it on a safe place.\n</span><span id=\"__span-1-16\"><a id=\"__codelineno-1-16\" name=\"__codelineno-1-16\" href=\"#__codelineno-1-16\"></a>\n</span><span id=\"__span-1-17\"><a id=\"__codelineno-1-17\" name=\"__codelineno-1-17\" href=\"#__codelineno-1-17\"></a>Then drag and drop the damaged drivers hive on the SequenceNumberChecker tool.\n</span><span id=\"__span-1-18\"><a id=\"__codelineno-1-18\" name=\"__codelineno-1-18\" href=\"#__codelineno-1-18\"></a>\n</span><span id=\"__span-1-19\"><a id=\"__codelineno-1-19\" name=\"__codelineno-1-19\" href=\"#__codelineno-1-19\"></a>The tool should then start and try’s to repair the hive.\n</span><span id=\"__span-1-20\"><a id=\"__codelineno-1-20\" name=\"__codelineno-1-20\" href=\"#__codelineno-1-20\"></a>\n</span><span id=\"__span-1-21\"><a id=\"__codelineno-1-21\" name=\"__codelineno-1-21\" href=\"#__codelineno-1-21\"></a>When you see the message:\n</span><span id=\"__span-1-22\"><a id=\"__codelineno-1-22\" name=\"__codelineno-1-22\" href=\"#__codelineno-1-22\"></a>\n</span><span id=\"__span-1-23\"><a id=\"__codelineno-1-23\" name=\"__codelineno-1-23\" href=\"#__codelineno-1-23\"></a>    Repairs have completed...press any key to exit\n</span><span id=\"__span-1-24\"><a id=\"__codelineno-1-24\" name=\"__codelineno-1-24\" href=\"#__codelineno-1-24\"></a>\n</span><span id=\"__span-1-25\"><a id=\"__codelineno-1-25\" name=\"__codelineno-1-25\" href=\"#__codelineno-1-25\"></a>Do it and then copy the repaired hive back in the config folder.\n</span></code></pre></div>\n<p>我把其中的 drivers 换成 components（我的 drivers 没坏，坏的是 components），之后 Windows 更新忽然就恢复正常了。看了看这个程序的源码，就是强制把 sequence number 改了，但这真的是合理的修复吗，不会产生新的数据不一致问题吗？问题是没了，但是我并没有得到彻底解决问题的安全感。</p>\n<h2 id=\"感想\">感想</h2>\n<p>每次修 Windows，都让我觉得整个过程稀里糊涂。看到一个报错，搜索一番，得到一大堆可能的修复方法，只能一个个试：修不好不知道原因，修好了也不知道原因。Windows 是闭源的，我看不到源码，不知道背后到底发生了什么；要是在 Linux 上，我早就翻源码去调试了。而且我也没有在 Windows 里配置 Agent，没法让 AI 现场反编译 Windows 程序，搞清楚这个报错到底从哪来。说到底就是稀里糊涂，不想用 Windows。</p>","date_modified":"2026-09-04T00:00:00+00:00","date_published":"2026-09-04T00:00:00+00:00","id":"https://jia.je/software/2026/09/04/windows-800703f1/","image":null,"tags":["software","windows"],"title":"记一次 Windows 更新 0x800703F1 错误的修复","url":"https://jia.je/software/2026/09/04/windows-800703f1/"},{"authors":[],"content_html":"<h1 id=\"谈谈龙芯的-loongleak-漏洞\">谈谈龙芯的 LoongLeak 漏洞</h1>\n<h2 id=\"背景\">背景</h2>\n<p>近日，龙芯龙架构 CPU LA464/LA664 微架构部分步进的漏洞 <a href=\"https://loongleakattack.com/\">LoongLeak</a> 正式披露，龙芯官方也发布了 <a href=\"https://www.loongson.cn/news/show?id=850\">公告</a>。作为公告中提到的“其他国内独立研究者”之一，我在此分享一下我的视角。</p>\n<!-- more -->\n\n<h2 id=\"发现和披露的过程\">发现和披露的过程</h2>\n<p>这些年来，我在龙架构上做了不少工作，从参与 AOSC 社区的龙架构移植，到后来专注于 <a href=\"https://jia.je/unofficial-loongarch-intrinsics-guide/\">LSX/LASX/LBT 指令集第三方文档</a> 的维护，一直持续关注龙架构处理器的微架构信息，包括安全特性。我也曾尝试在龙架构上复现一些经典的攻击手段，比如 Meltdown，当然最终并未成功，这说明硬件层面已做了相应防护。最近我也在做一些微架构攻击方面的研究，比如一篇对苹果分支预测器攻击的论文被 ACM CCS 26 录用（<a href=\"https://craft.cs.tsinghua.edu.cn/publication/ienflow-endogenous-control-flow-attacks-via-conditional-branch-prediction-on-apple-silicon/\">iEnFlow</a>），所以也自然而然地研究到了龙芯上。</p>\n<p>今年五月，我开始梳理可能适用于龙架构的经典微架构攻击方法，其中注意到了 <a href=\"https://lock.cmpxchg8b.com/zenbleed.html\">ZenBleed</a>。该漏洞揭示了 AMD 处理器上 AVX 寄存器数据泄露的问题。我几年前曾在 EPYC 处理器上复现过此漏洞，印象深刻：这类缺陷极为隐蔽，难以通过常规测试发现，触发条件苛刻（因此是通过模糊测试挖掘出来的），但确实能够泄漏物理寄存器中残留的数据。该漏洞后来通过微码更新得以修复。</p>\n<p>回顾 ZenBleed 时，我联想到 Chips and Cheese 在 2023 年发布的分析文章 <a href=\"https://chipsandcheese.com/p/loongsons-lsx-and-lasx-vector-extensions\">Loongson’s LSX and LASX Vector Extensions</a>，其中提到执行 LSX 指令后，向量寄存器的高位部分可能出现“随机”数值。文章并未从漏洞角度深入探究，但结合 ZenBleed 的经验，我很快意识到这很可能同样源于未清空的物理寄存器数据。随后我进行了一系列实验，迅速在 LA464 和 LA664 两个微架构上复现了类似 ZenBleed 的漏洞，并将其命名为 LoongBleed。</p>\n<p>5 月 12 日，我向龙芯公司提交了漏洞报告。他们迅速完成了复现，并将其转交给 CPU 团队。6 月 9 日，我收到通知：这是一个已知漏洞的独立发现。这意味着在我之前，已有其他研究者发现了该漏洞并报告给了龙芯，我推测这应该就是 LoongLeak 作者团队的工作。此后我按照漏洞披露的惯例继续保密，直至官方公开披露，我才将相关信息公开。此前我将其命名为 LoongBleed（因其与 ZenBleed 在原理和现象上相似），源代码已托管于 <a href=\"https://github.com/jiegec/LoongBleed\">LoongBleed</a> 仓库。LoongLeak 与 LoongBleed 本质上是同一漏洞，只是触发方式略有差异，由两个团队（我的团队即我本人）独立发现。</p>\n<h2 id=\"漏洞原理与修复\">漏洞原理与修复</h2>\n<p>关于该漏洞的原理，目前存在两种推测：一是 LoongLeak 论文中提出的从 L1D 缓存行泄露数据；二是我更倾向的物理寄存器高位未清空假说。目前我尚未深入验证哪种推测成立，亦可能两者并存。但无论如何，LASX 寄存器的高位部分在执行 LSX 指令后本不应被使用，更不应泄露数据，正如 ZenBleed 那样。</p>\n<p>至于修复方式，在微架构层面应设法固定多余的位数，例如置为全零或全一。具体实现方案取决于泄漏的根源，需补充相应逻辑。对于存在漏洞的硬件，能否修复取决于是否预留了相关的控制位（chicken bit）以屏蔽问题逻辑路径。但由于龙芯处理器不支持微码更新，无法像 AMD 那样通过发布微码来修补。</p>\n<p>从危害程度来看，攻击者若获取本地执行权限，即可泄漏部分原本不可访问的敏感信息，不过这些数据是碎片化的，拼凑难度较大。总体而言，其危害相比 <a href=\"https://ghostwriteattack.com/\">GhostWrite</a> 那类任意内存读写的漏洞要弱得多。</p>\n<h2 id=\"对龙芯的观察\">对龙芯的观察</h2>\n<p>在这次漏洞披露流程中，龙芯的表现总体得体，尽管这可能是首个公开的龙芯微架构漏洞。此次事件之后，势必会有更多研究者将目光投向龙架构。尤其是 USENIX Security 26 上那篇 LoongLeak 论文发表后，新的研究方向已被开辟，此前各类攻击方法很可能被陆续移植到龙架构上进行测试，出现新漏洞也并非意外。</p>\n<p>这也为龙芯提出了新的挑战：如何在微架构设计阶段，既追求性能，又充分考虑安全性，并做好冗余设计，以便在安全问题出现时拥有足够的应对手段。不过，所有处理器厂商都是这样走过来的。即便是 Intel，至今仍在持续修复各类硬件漏洞，只是像当年 Meltdown 那样可读取任意地址的严重漏洞确实越来越少了。可以说，这是处理器发展过程中必经的阶段。</p>\n<p>最后，祝龙芯越来越好。</p>","date_modified":"2026-08-18T00:00:00+00:00","date_published":"2026-08-18T00:00:00+00:00","id":"https://jia.je/hardware/2026/08/18/loongleak-loongbleed/","image":null,"tags":["cpu","hardware","loongarch","loongson"],"title":"谈谈龙芯的 LoongLeak 漏洞","url":"https://jia.je/hardware/2026/08/18/loongleak-loongbleed/"},{"authors":[],"content_html":"<h1 id=\"ampere-skylark-微架构评测\">Ampere Skylark 微架构评测</h1>\n<h2 id=\"背景\">背景</h2>\n<p>Ampere eMAG 采用的是 Ampere Skylark 微架构，虽然是 2018 年的处理器了，但也顺带评测一下。其前身是 AppliedMicro 的 X-Gene 3 微架构，用在 Ampere eMAG 芯片上，用的是 TSMC 16nm FinFET+ 工艺。</p>\n<!-- more -->\n\n<h2 id=\"官方信息\">官方信息</h2>\n<p>只找到了 X-Gene 2，即 Skylark 更早一代的信息：<a href=\"https://old.hotchips.org/wp-content/uploads/hc_archives/hc26/HC26-11-day1-epub/HC26.11-4-ARM-Servers-epub/HC26.11.430-X-Gene-Singh-AppMicro-HotChips-2014-v5.pdf\">AppliedMicro X-Gene2</a></p>\n<h2 id=\"前端\">前端</h2>\n<h3 id=\"取指带宽\">取指带宽</h3>\n<p>为了测试实际的 Fetch 宽度，参考 <a href=\"https://zhuanlan.zhihu.com/p/720136752\">如何测量真正的取指带宽（I-fetch width） - JamesAslan</a> 构造了测试，实验结果如下：</p>\n<p><img alt=\"\" src=\"../../../../ampere-skylark-if-width.png\" /></p>\n<p>可见取指带宽是每周期四条指令，并且很多时候并不能打满。</p>\n<p><a href=\"https://github.com/jiegec/cpu-micro-benchmarks/blob/master/src/if_width_gen.cpp\">测试过程详见测试代码</a>。</p>\n<h3 id=\"l1-icache\">L1 ICache</h3>\n<p>为了测试 L1 ICache 容量，构造一个具有巨大指令 footprint 的循环，由大量的 nop 和最后的分支指令组成。观察在不同 footprint 大小下的 IPC：</p>\n<p><img alt=\"\" src=\"../../../../ampere-skylark-fetch-bandwidth.png\" /></p>\n<p>可以看到 footprint 在 32 KB 之前时可以达到 4 IPC，这对应了 32KB 的 L1 ICache。</p>\n<p><a href=\"https://github.com/jiegec/cpu-micro-benchmarks/blob/master/src/fetch_bandwidth_gen.cpp\">测试过程详见测试代码</a>。</p>\n<h3 id=\"btb\">BTB</h3>\n<p>构造大量的无条件分支指令（B 指令），BTB 需要记录这些指令的目的地址，那么如果分支数量超过了 BTB 的容量，性能会出现明显下降。当把大量 B 指令紧密放置，也就是每 4 字节一条 B 指令时：</p>\n<p><img alt=\"\" src=\"../../../../ampere-skylark-btb-4b.png\" /></p>\n<p>可见 Skylark 的 BTB 对分支紧密放置的情况支持不是很好，在 1024 个分支之内的 CPI 达到了 3.5，这一点在较早的处理器上比较常见，比如 <a href=\"../../../../2025/06/05/arm-neoverse-n1-btb/\">Neoverse N1 的 BTB</a>，不过稍微新一些的处理器，随着设计的改进，类似的情况比较少见了。之后到 8192 个分支，CPI 达到了 5。接着降低分支指令的密度，在 B 指令之间插入 NOP 指令，使得每 8 个字节有一条 B 指令，得到如下结果：</p>\n<p><img alt=\"\" src=\"../../../../ampere-skylark-btb-8b.png\" /></p>\n<p>这个图像就比较正常了，CPI=2 持续到了 512 个分支，对应上面 1024 个分支的拐点前移，之后 CPI=5 的拐点在 4096，对应了上面 8192 的拐点。考虑到它的 L1 ICache 是 32 KB，正好对应 8192 的拐点，可以认为 Skylark 的 BTB 是：</p>\n<ul>\n<li>1024-entry, 2 cycle latency 的 L1 BTB</li>\n<li>32 KB 的 L1 ICache 作为 L2 BTB</li>\n</ul>\n<p><a href=\"https://github.com/jiegec/cpu-micro-benchmarks/blob/master/src/btb_size_basic_gen.cpp\">测试过程详见测试代码</a>。</p>\n<h3 id=\"l1-itlb\">L1 ITLB</h3>\n<p>构造一系列的 B 指令，使得 B 指令分布在不同的 page 上，使得 ITLB 成为瓶颈：</p>\n<p><img alt=\"\" src=\"../../../../ampere-skylark-itlb-size.png\" /></p>\n<p>在 48 个页时，CPI 从 2 提升到了 8，意味着 L1 ITLB 容量是 48。</p>\n<p><a href=\"https://github.com/jiegec/cpu-micro-benchmarks/blob/master/src/itlb_size_lib.cpp\">测试过程详见测试代码</a>。</p>\n<h3 id=\"return-stack\">Return Stack</h3>\n<p>构造不同深度的调用链，测试每次调用花费的平均时间，得到下面的图：</p>\n<p><img alt=\"\" src=\"../../../../ampere-skylark-ras-size.png\" /></p>\n<p>可以看到调用链深度超过 16 时性能突然变差，因此 Skylark 的 Return Stack 深度为 16。</p>\n<p><a href=\"https://github.com/jiegec/cpu-micro-benchmarks/blob/master/src/ras_size_gen.cpp\">测试过程详见测试代码</a>。</p>\n<h2 id=\"后端\">后端</h2>\n<h3 id=\"load-store-unit--l1-dcache\">Load Store Unit + L1 DCache</h3>\n<h4 id=\"l1-dcache-容量\">L1 DCache 容量</h4>\n<p>构造不同大小 footprint 的 pointer chasing 链，测试不同 footprint 下每条 load 指令耗费的时间：</p>\n<p><img alt=\"\" src=\"../../../../ampere-skylark-l1dc.png\" /></p>\n<p>可以看到 32KB 出现了拐点，对应的就是 32KB 的 L1 DCache 容量，和官方信息一致，访存延迟从 5 cycle 增加到 13 cycle。</p>\n<p><a href=\"https://github.com/jiegec/cpu-micro-benchmarks/blob/master/src/memory_latency.cpp\">测试过程详见测试代码</a>。</p>\n<h4 id=\"l1-dtlb-容量\">L1 DTLB 容量</h4>\n<p>用类似的方法测试 L1 DTLB 容量，只不过这次 pointer chasing 链的指针分布在不同的 page 上，使得 DTLB 成为瓶颈：</p>\n<p><img alt=\"\" src=\"../../../../ampere-skylark-l1dtlb.png\" /></p>\n<p>从 48 个页开始性能下降，认为 Skylark 的 L1 DTLB 有 48 项，访存延迟从 5 cycle 增加到 11 cycle。</p>\n<p><a href=\"https://github.com/jiegec/cpu-micro-benchmarks/blob/master/src/dtlb_size.cpp\">测试过程详见测试代码</a>。</p>\n<h4 id=\"loadstore-带宽\">Load/Store 带宽</h4>\n<p>针对 Load Store 带宽，实测 Skylark 每个周期可以完成：</p>\n<ul>\n<li>1x 64b Load</li>\n<li>1x 64b Load + 1x 64b Store</li>\n<li>1x 64b Store</li>\n</ul>\n<p>如果把每条指令的访存位宽从 64b 改成 128b，读写带宽不变，指令吞吐减半。也就是说最大的读带宽是 8B/cyc，最大的写带宽是 8B/cyc，可以同时达到。</p>\n<h4 id=\"store-to-load-forwarding\">Store to Load Forwarding</h4>\n<p>经过实际测试，Skylark 上如下的情况可以成功转发，对地址 x 的 Store 转发到对地址 y 的 Load 成功时 y-x 的取值范围：</p>\n<table>\n<thead>\n<tr>\n<th>Store\\Load</th>\n<th>8b Load</th>\n<th>16b Load</th>\n<th>32b Load</th>\n<th>64b Load</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>8b Store</td>\n<td>{0}</td>\n<td>{}</td>\n<td>{}</td>\n<td>{}</td>\n</tr>\n<tr>\n<td>16b Store</td>\n<td>[0,1]</td>\n<td>{0}</td>\n<td>{}</td>\n<td>{}</td>\n</tr>\n<tr>\n<td>32b Store</td>\n<td>[0,3]</td>\n<td>[0,2]</td>\n<td>{0}</td>\n<td>{}</td>\n</tr>\n<tr>\n<td>64b Store</td>\n<td>[0,7]</td>\n<td>[0,6]</td>\n<td>[0,4]</td>\n<td>{0}</td>\n</tr>\n</tbody>\n</table>\n<p>转发的性能分以下几种情况：</p>\n<ol>\n<li>满足上表中情况，即 Store 完全包括了 Load，则可以成功转发，4.5 Cycle，支持跨 64B 缓存行边界</li>\n<li>特别地，如果 Load 跨越了对齐的 8B 边界，则延迟提高到 12 Cycle</li>\n<li>特别地，如果 Store 没有完全包含 Load，但在某个对齐的 8B 块内，Store 完全包含了 Load，则延迟提高到 9 Cycle</li>\n<li>否则，转发失败，27 Cycle</li>\n</ol>\n<p>从这个现象，大概可以猜到，Skylark 是以 4B 为粒度，检查 Store 和 Load 的覆盖情况，如果 Store 可以完全覆盖 Load，就进行转发。</p>\n<p>特别地，即使访问的范围没有重合，也就是不需要 Forwarding 的情况，如果 Load 和 Store 在同一个对齐的 4B 块内，或者 Store 跨越了对齐的 8B 边界，也会多一个周期。</p>\n<p>一个 Load 需要转发两个、四个甚至八个 Store 的数据时，不能转发。</p>\n<p>小结：Skylark 的 Store to Load Forwarding：</p>\n<ul>\n<li>1 ld + 1 st: 要求 Store 覆盖 Load</li>\n<li>1 ld + 2/4/8 st: 不支持</li>\n</ul>\n<p>Forwarding 能力和 AMD Zen 5 比较类似。</p>\n<h4 id=\"load-to-use-latency\">Load to use latency</h4>\n<p>实测 Skylark 在下列的场景下可以达到 5 cycle:</p>\n<ul>\n<li><code>ldr x0, [x0]</code>: load 结果转发到基地址，无偏移</li>\n<li><code>ldr x0, [x0, 8]</code>：load 结果转发到基地址，有立即数偏移</li>\n<li><code>ldr x0, [x0, x1]</code>：load 结果转发到基地址，有寄存器偏移</li>\n<li><code>ldr x0, [sp, x0, lsl #3]</code>：load 结果转发到 index</li>\n<li><code>ldp x0, x1, [x0]</code>：load pair 的第一个目的寄存器转发到基地址，无偏移</li>\n<li>load 的目的寄存器作为 alu 的源寄存器（下称 load to alu latency）</li>\n</ul>\n<p>下列情况需要 6 cycle：</p>\n<ul>\n<li><code>ldp x1, x0, [x0]</code>：load pair 的第二个目的寄存器转发到基地址，无偏移</li>\n<li>访存跨越 64B 边界</li>\n</ul>\n<h4 id=\"virtual-address-utagway-predictor\">Virtual Address UTag/Way-Predictor</h4>\n<p>Linear Address UTag/Way-Predictor 是 AMD 的叫法，但使用相同的测试方法，也可以在 Ampere Skylark 上观察到类似的现象，猜想它也用了类似的基于虚拟地址的 UTag/Way Predictor 方案，并测出来它的 UTag 也有 12 bit：</p>\n<ul>\n<li>VA[12] xor VA[24] xor VA[36]</li>\n<li>VA[13] xor VA[25] xor VA[37]</li>\n<li>VA[14] xor VA[26] xor VA[38]</li>\n<li>VA[15] xor VA[27] xor VA[39]</li>\n<li>VA[16] xor VA[28] xor VA[40]</li>\n<li>VA[17] xor VA[29] xor VA[41]</li>\n<li>VA[18] xor VA[30] xor VA[43]</li>\n<li>VA[19] xor VA[31] xor VA[44]</li>\n<li>VA[20] xor VA[32]</li>\n<li>VA[21] xor VA[33] xor VA[46]</li>\n<li>VA[22] xor VA[34]</li>\n<li>VA[23] xor VA[35]</li>\n</ul>\n<h3 id=\"执行单元\">执行单元</h3>\n<p>想要测试有多少个执行单元，每个执行单元可以运行哪些指令，首先要测试各类指令在无依赖情况下的 IPC，通过 IPC 来推断有多少个能够执行这类指令的执行单元；但由于一个执行单元可能可以执行多类指令，于是进一步需要观察在混合不同类的指令时的 IPC，从而推断出完整的结果。测试如下各类指令的延迟和每周期吞吐：</p>\n<table>\n<thead>\n<tr>\n<th>指令</th>\n<th>延迟</th>\n<th>吞吐</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>asimd int add</td>\n<td>3</td>\n<td>0.5</td>\n</tr>\n<tr>\n<td>asimd aesd/aese</td>\n<td>5</td>\n<td>0.25</td>\n</tr>\n<tr>\n<td>asimd aesimc/aesmc</td>\n<td>2</td>\n<td>0.5</td>\n</tr>\n<tr>\n<td>asimd fabs</td>\n<td>2</td>\n<td>0.5</td>\n</tr>\n<tr>\n<td>asimd fadd</td>\n<td>5/6</td>\n<td>0.5</td>\n</tr>\n<tr>\n<td>asimd fdiv 64b</td>\n<td>22</td>\n<td>1/lat</td>\n</tr>\n<tr>\n<td>asimd fdiv 32b</td>\n<td>22</td>\n<td>1/lat</td>\n</tr>\n<tr>\n<td>asimd fmax</td>\n<td>3</td>\n<td>0.5</td>\n</tr>\n<tr>\n<td>asimd fmin</td>\n<td>3</td>\n<td>0.5</td>\n</tr>\n<tr>\n<td>asimd fmla</td>\n<td>6</td>\n<td>0.5</td>\n</tr>\n<tr>\n<td>asimd fmul</td>\n<td>6</td>\n<td>0.5</td>\n</tr>\n<tr>\n<td>asimd fneg</td>\n<td>2</td>\n<td>0.5</td>\n</tr>\n<tr>\n<td>asimd frecpe</td>\n<td>3</td>\n<td>0.5</td>\n</tr>\n<tr>\n<td>asimd frsqrte</td>\n<td>5</td>\n<td>0.5</td>\n</tr>\n<tr>\n<td>asimd fsqrt 64b</td>\n<td>76</td>\n<td>1/lat</td>\n</tr>\n<tr>\n<td>asimd fsqrt 32b</td>\n<td>48</td>\n<td>1/lat</td>\n</tr>\n<tr>\n<td>fp fabs</td>\n<td>2</td>\n<td>1</td>\n</tr>\n<tr>\n<td>fp fadd</td>\n<td>5/6</td>\n<td>1</td>\n</tr>\n<tr>\n<td>fp fdiv 64b</td>\n<td>17</td>\n<td>1/11</td>\n</tr>\n<tr>\n<td>fp fdiv 32b</td>\n<td>17</td>\n<td>1/11</td>\n</tr>\n<tr>\n<td>fp fmax</td>\n<td>3</td>\n<td>1</td>\n</tr>\n<tr>\n<td>fp fmin</td>\n<td>3</td>\n<td>1</td>\n</tr>\n<tr>\n<td>fp fmul</td>\n<td>6</td>\n<td>1</td>\n</tr>\n<tr>\n<td>fp fneg</td>\n<td>2</td>\n<td>1</td>\n</tr>\n<tr>\n<td>fp frecpe</td>\n<td>3</td>\n<td>1</td>\n</tr>\n<tr>\n<td>fp frecpx</td>\n<td>3</td>\n<td>1</td>\n</tr>\n<tr>\n<td>fp frsqrte</td>\n<td>5</td>\n<td>1</td>\n</tr>\n<tr>\n<td>fp fsqrt 64b</td>\n<td>44</td>\n<td>1/38</td>\n</tr>\n<tr>\n<td>fp fsqrt 32b</td>\n<td>28</td>\n<td>1/22</td>\n</tr>\n<tr>\n<td>int add</td>\n<td>1</td>\n<td>2</td>\n</tr>\n<tr>\n<td>int addi</td>\n<td>1</td>\n<td>2</td>\n</tr>\n<tr>\n<td>int bfm</td>\n<td>2</td>\n<td>1</td>\n</tr>\n<tr>\n<td>int crc</td>\n<td>2</td>\n<td>1</td>\n</tr>\n<tr>\n<td>int csel</td>\n<td>1</td>\n<td>2</td>\n</tr>\n<tr>\n<td>int madd (addend)</td>\n<td>2</td>\n<td>0.5</td>\n</tr>\n<tr>\n<td>int madd (others)</td>\n<td>6</td>\n<td>0.5</td>\n</tr>\n<tr>\n<td>int mrs nzcv</td>\n<td>-</td>\n<td>1</td>\n</tr>\n<tr>\n<td>int mul</td>\n<td>5</td>\n<td>0.5</td>\n</tr>\n<tr>\n<td>int nop</td>\n<td>-</td>\n<td>4</td>\n</tr>\n<tr>\n<td>int sbfm</td>\n<td>2</td>\n<td>1</td>\n</tr>\n<tr>\n<td>int sdiv</td>\n<td>7</td>\n<td>1/lat</td>\n</tr>\n<tr>\n<td>int smull</td>\n<td>4</td>\n<td>1</td>\n</tr>\n<tr>\n<td>int ubfm</td>\n<td>2</td>\n<td>1</td>\n</tr>\n<tr>\n<td>int udiv</td>\n<td>7</td>\n<td>1/lat</td>\n</tr>\n<tr>\n<td>not taken branch</td>\n<td>-</td>\n<td>1</td>\n</tr>\n<tr>\n<td>taken branch</td>\n<td>-</td>\n<td>0.3</td>\n</tr>\n</tbody>\n</table>\n<p>可见它的执行单元不多，只有 2x ALU，1x Branch，1x Load，1x Store，1x FP，其中 ASIMD 拆成两个 64b 的部分分别计算，即 FP 的 datapath 只有 64b 宽。</p>\n<h3 id=\"reorder-buffer\">Reorder Buffer</h3>\n<p>用 NOP 指令测试 Skylark 的 ROB 大小：</p>\n<p><img alt=\"\" src=\"../../../../ampere-skylark-rob.png\" /></p>\n<p>可以看到拐点是 60 条指令。</p>\n<h3 id=\"l2-cache\">L2 Cache</h3>\n<p>构造不同大小 footprint 的 pointer chasing 链，测试不同 footprint 下每条 load 指令耗费的时间，这次把容量扩充到 L2 Cache 的范围：</p>\n<p><img alt=\"\" src=\"../../../../ampere-skylark-l2dc.png\" /></p>\n<p>可以看到 192KB 出现了拐点，对应 13 Cycle。<code>lscpu -C</code> 报告的实际容量为 256KB，意味着对单个核心的数据占用的 L2 Cache 容量有限制。</p>\n<p><a href=\"https://github.com/jiegec/cpu-micro-benchmarks/blob/master/src/memory_latency.cpp\">测试过程详见测试代码</a>。</p>\n<h3 id=\"l2-tlb\">L2 TLB</h3>\n<p>沿用 L1 DTLB 的测试，继续扩大测试的范围，找到新的拐点：</p>\n<p><img alt=\"\" src=\"../../../../ampere-skylark-l2dtlb.png\" /></p>\n<p>意味着 L2 TLB 容量是 512。</p>\n<h2 id=\"总结\">总结</h2>\n<p>Skylark 是比较早期的 ARM server core，配置如下：</p>\n<ul>\n<li>4-wide</li>\n<li>32 KB L1 ICache/DCache</li>\n<li>1024-entry BTB</li>\n<li>48-entry L1 ITLB/DTLB</li>\n<li>16-entry RAS</li>\n<li>60-entry ROB</li>\n<li>执行单元只有 2 ALU + 1 Branch + 1 Load + 1 Store + 1 FP</li>\n</ul>","date_modified":"2026-07-07T00:00:00+00:00","date_published":"2026-07-07T00:00:00+00:00","id":"https://jia.je/hardware/2026/07/07/ampere-skylark/","image":null,"tags":["ampere","cpu","hardware","performance","skylark","uarch-review"],"title":"Ampere Skylark 微架构评测","url":"https://jia.je/hardware/2026/07/07/ampere-skylark/"},{"authors":[],"content_html":"<h1 id=\"apple-m2-avalanche--blizzard-微架构评测\">Apple M2 (Avalanche &amp; Blizzard) 微架构评测</h1>\n<h2 id=\"背景\">背景</h2>\n<p>之前分析过 <a href=\"../../../../2024/12/26/apple-m1/\">M1</a> 和 <a href=\"../../../../2025/05/21/apple-m4/\">M4</a>，趁着机会，也评测一下 M2 的微架构，给出一个从 M1 到 M2 再到 M4 的发展脉络。</p>\n<!-- more -->\n\n<h2 id=\"官方信息\">官方信息</h2>\n<p>苹果发布了 <a href=\"https://developer.apple.com/download/apple-silicon-cpu-optimization-guide/\">Apple Silicon CPU Optimization Guide</a>，包括了一些 M2 的微架构信息。</p>\n<h2 id=\"现有评测\">现有评测</h2>\n<p>网上已经有针对 Apple M2 微架构的评测和分析，建议阅读：</p>\n<ul>\n<li><a href=\"https://www.bilibili.com/video/BV18B4y1b7gj/\">我们找到了 Windows 电脑续航差的原因！苹果 M2 深度分析</a></li>\n<li><a href=\"https://zhuanlan.zhihu.com/p/662561990\">不为人知的角落，Apple M2 的小小努力（其一）</a></li>\n<li><a href=\"https://zhuanlan.zhihu.com/p/675322260\">Apple M2 Blizzard 微架构评测 (上)：阳春白雪</a></li>\n<li><a href=\"https://zhuanlan.zhihu.com/p/678983061\">Apple M2 Blizzard 微架构评测 (中)：阳春白雪</a></li>\n</ul>\n<p>下面分各个模块分别记录官方提供的信息，以及实测的结果。读者可以对照已有的第三方评测理解。官方信息与实测结果一致的数据会加粗。</p>\n<h2 id=\"benchmark\">Benchmark</h2>\n<p>Apple M2 Avalanche/Blizzard 的性能测试结果见 <a href=\"../../../../../benchmark/\">SPEC</a>。</p>\n<h2 id=\"前端\">前端</h2>\n<h3 id=\"取指带宽\">取指带宽</h3>\n<h4 id=\"avalanche\">Avalanche</h4>\n<p>为了测试实际的 Fetch 宽度，参考 <a href=\"https://zhuanlan.zhihu.com/p/720136752\">如何测量真正的取指带宽（I-fetch width） - JamesAslan</a> 构造了测试，实验结果如下：</p>\n<p><img alt=\"\" src=\"../../../../apple-m2-avalanche-if-width.png\" /></p>\n<p>可以看到每 16 条指令会多一个周期，因此 Avalanche 的前端取指宽度确实是 16 条指令，与 Apple M1 Firestorm 和 Apple M4 P-Core 都相同。</p>\n<h4 id=\"blizzard\">Blizzard</h4>\n<p>用相同的方式测试 Blizzard，结果如下：</p>\n<p><img alt=\"\" src=\"../../../../apple-m2-blizzard-if-width.png\" /></p>\n<p>可以看到每 8 条指令会多一个周期，意味着 Blizzard 的前端取指宽度为 8 条指令，和 Apple M1 Icestorm 相同，不过表现在图像上不太一样。</p>\n<p><a href=\"https://github.com/jiegec/cpu-micro-benchmarks/blob/master/src/if_width_gen.cpp\">测试过程详见测试代码</a>。</p>\n<h3 id=\"l1-icache\">L1 ICache</h3>\n<p>官方信息：根据 Apple Silicon CPU Optimization Guide，从 M1 Family 到 M4 Family，A14 Bionic 到 A18 Family，P-Core 的 L1 ICache 的配置都是 192KiB, 6-way, 64B lines；对应处理器的 E-Core 的 L1 ICache 都是 128KiB, 64B lines，其中 M1 Family 和 A14 Bionic 是 8-way，其余处理器（M2 Family 和 A15 Bionic 开始）是 4-way。</p>\n<p>容量和 Apple M1 相同。</p>\n<h4 id=\"avalanche_1\">Avalanche</h4>\n<p>为了测试 L1 ICache 容量，构造一个具有巨大指令 footprint 的循环，由大量的 nop 和最后的分支指令组成。观察在不同 footprint 大小下 Avalanche 的 IPC：</p>\n<p><img alt=\"\" src=\"../../../../apple-m2-avalanche-fetch-bandwidth.png\" /></p>\n<p>可以看到 footprint 在 192 KB 之前时可以达到 8 IPC，之后则快速降到 2 IPC，这里的 192 KB 就对应了 Avalanche 的 L1 ICache 的容量，和官方信息一致。虽然 Fetch 可以每周期 16 条指令，也就是一条 64B 的缓存行，由于后端的限制，只能观察到 8 的 IPC。IPC 与 Apple M1 Firestorm 相同，不及 Apple M4 P-Core 的 10 IPC。</p>\n<h4 id=\"blizzard_1\">Blizzard</h4>\n<p>用相同的方式测试 Blizzard，结果如下：</p>\n<p><img alt=\"\" src=\"../../../../apple-m2-blizzard-fetch-bandwidth.png\" /></p>\n<p>可以看到 footprint 在 128 KB 之前时可以达到 5 IPC，之后则快速降到 2.32 IPC，这里的 128 KB 就对应了 Blizzard 的 L1 ICache 的容量，和官方信息一致。虽然 Fetch 可以每周期 8 条指令，由于后端的限制，只能观察到 5 的 IPC。相比 Apple M1 Icestorm，IPC 从 4 增加到了 5，与 Apple M4 E-Core 相同。</p>\n<p><a href=\"https://github.com/jiegec/cpu-micro-benchmarks/blob/master/src/fetch_bandwidth_gen.cpp\">测试过程详见测试代码</a>。</p>\n<h3 id=\"btb\">BTB</h3>\n<h4 id=\"avalanche_2\">Avalanche</h4>\n<p>构造大量的无条件分支指令（B 指令），BTB 需要记录这些指令的目的地址，那么如果分支数量超过了 BTB 的容量，性能会出现明显下降。当把大量 B 指令紧密放置，也就是每 4 字节一条 B 指令时：</p>\n<p><img alt=\"\" src=\"../../../../apple-m2-avalanche-btb-4b.png\" /></p>\n<p>可见在 1024 个分支之内可以达到 1 的 CPI，超过 1024 个分支，CPI 先升后降，在 4096 个分支时 CPI 等于 2，此后 CPI 逐渐上升，到 49152 个分支 CPI 等于 3。49152 的拐点，对应的是指令 footprint 超出 L1 ICache 的情况：L1 ICache 是 192KB，按照每 4 字节一个 B 指令计算，最多可以存放 49152 条 B 指令。</p>\n<p>降低分支指令的密度，在 B 指令之间插入 NOP 指令，使得每 8 个字节有一条 B 指令，得到如下结果：</p>\n<p><img alt=\"\" src=\"../../../../apple-m2-avalanche-btb-8b.png\" /></p>\n<p>可以看到 CPI=1 的拐点前移到 512 个分支，同时 CPI=3 的拐点也前移到了 24576。拐点的前移，意味着 BTB 采用了组相连的结构，当 B 指令的 PC 的部分低位总是为 0 时，组相连的 Index 可能无法取到所有的 Set，导致表现出来的 BTB 容量只有部分 Set，例如此处容量减半，说明只有一半的 Set 被用到了。</p>\n<p>相比 Apple M1 Firestorm，Avalanche 在 L1 和 L1 ICache 之间多加了一级 BTB，从而能够在更大的范围内，实现小于 3 的 CPI。相比 Apple M4 P-Core，Avalanche 在容量和延迟上都有差距。</p>\n<h4 id=\"blizzard_2\">Blizzard</h4>\n<p>用相同的方式测试 Blizzard，首先用 4B 的间距：</p>\n<p><img alt=\"\" src=\"../../../../apple-m2-blizzard-btb-4b.png\" /></p>\n<p>可以看到 1024 的拐点，1024 之前是 1 IPC，之后增加到 3 IPC。比较奇怪的是，没有看到第二个拐点，第二个拐点在 8B 的间距下显现：</p>\n<p><img alt=\"\" src=\"../../../../apple-m2-blizzard-btb-8b.png\" /></p>\n<p>第一个拐点前移到 512，第二个拐点出现在 16384，而 Blizzard 的 L1 ICache 容量是 128KB，8B 间距下正好可以保存 16384 个分支。</p>\n<p>用 16B 间距测试：</p>\n<p><img alt=\"\" src=\"../../../../apple-m2-blizzard-btb-16b.png\" /></p>\n<p>第一个拐点前移到 256，第二个拐点出现在 8192，对应 L1 ICache 容量。</p>\n<p>从 BTB 容量来看，Blizzard 与 Apple M1 Icestorm 以及 Apple M4 E-Core 相同。</p>\n<p><a href=\"https://github.com/jiegec/cpu-micro-benchmarks/blob/master/src/btb_size_basic_gen.cpp\">测试过程详见测试代码</a>。</p>\n<h3 id=\"l1-itlb\">L1 ITLB</h3>\n<p>官方信息：根据 Apple Silicon CPU Optimization Guide，从 M1 Family 到 M4 Family，A14 Bionic 到 A18 Family，其 P-Core 的 L1 ITLB 配置都是一样的：192 entries，考虑到每个页是 16 KiB，对应 3 MiB 的内存；E-Core 的话，M1 Family 和 A14 Bionic 的 L1 ITLB 是 128 entries，之后的处理器（M2 Family 和 A15 Bionic 开始）则 E-Core 也是 192 entries。</p>\n<p>因此，M2 Avalanche L1 ITLB 是 192 entries，Blizzard L1 ITLB 是 192 entries。</p>\n<h4 id=\"avalanche_3\">Avalanche</h4>\n<p>构造一系列的 B 指令，使得 B 指令分布在不同的 page 上，使得 ITLB 成为瓶颈，在 Avalanche 上进行测试：</p>\n<p><img alt=\"\" src=\"../../../../apple-m2-avalanche-itlb-size.png\" /></p>\n<p>在 192 个页时从 2 Cycle 快速增加到 11 Cycle，对应了 192 项的 L1 ITLB 容量，和官方信息一致。</p>\n<h4 id=\"blizzard_3\">Blizzard</h4>\n<p>在 Blizzard 上重复实验：</p>\n<p><img alt=\"\" src=\"../../../../apple-m2-blizzard-itlb-size.png\" /></p>\n<p>在 192 个页时，性能从 1 Cycle 下降到 10 Cycle，意味着 L1 ITLB 容量是 192 项，和官方信息一致。</p>\n<p><a href=\"https://github.com/jiegec/cpu-micro-benchmarks/blob/master/src/itlb_size_lib.cpp\">测试过程详见测试代码</a>。</p>\n<h3 id=\"decode\">Decode</h3>\n<p>官方信息：根据 Apple Silicon CPU Optimization Guide，M1 Family 的 Sustained uops Per Cycle 最大值，P-Core 是 8，E-Core 是 4；M2 Family 的 P-Core 不变还是 <strong>8</strong>，E-Core 提升到了 <strong>5</strong>；M3 Family 的 P-Core 提升到了 9，E-Core 和 M2 持平；M4 Family 的 P-Core 进一步提升到了 10，E-Core 继续和 M2 持平。</p>\n<p>从前面的测试来看，Avalanche 最大观察到 8 IPC，Blizzard 最大观察到 5 IPC，那么 Decode 宽度也至少是这么多，暂时也不能排除有更大的 Decode 宽度，和官方信息一致。</p>\n<h3 id=\"return-stack\">Return Stack</h3>\n<h4 id=\"avalanche_4\">Avalanche</h4>\n<p>构造不同深度的调用链，测试每次调用花费的平均时间，在 Avalanche 上得到下面的图：</p>\n<p><img alt=\"\" src=\"../../../../apple-m2-avalanche-ras-size.png\" /></p>\n<p>可以看到调用链深度为 50 时性能突然变差，因此 Avalanche 的 Return Stack 深度为 50。和 Apple M1 Firestorm 相同，比 Apple M4 P-Core 的 60 要小。</p>\n<h4 id=\"blizzard_4\">Blizzard</h4>\n<p>在 Blizzard 上测试：</p>\n<p><img alt=\"\" src=\"../../../../apple-m2-blizzard-ras-size.png\" /></p>\n<p>可以看到调用链深度为 32 时性能突然变差，因此 Blizzard 的 Return Stack 深度为 32。与 Apple M1 Icestorm 相同，比 Apple M4 E-Core 的 40 要小。</p>\n<p><a href=\"https://github.com/jiegec/cpu-micro-benchmarks/blob/master/src/ras_size_gen.cpp\">测试过程详见测试代码</a>。</p>\n<h3 id=\"conditional-branch-predictor\">Conditional Branch Predictor</h3>\n<p>参考 <a href=\"https://arxiv.org/abs/2411.13900\">Dissecting Conditional Branch Predictors of Apple Firestorm and Qualcomm Oryon for Software Optimization and Architectural Analysis</a> 论文的方法，可以测出 Avalanche 的分支预测器与 Apple M1 Firestorm 相同，采用的历史更新方式为：</p>\n<ol>\n<li>使用 100 位的 Path History Register for Target(PHRT) 以及 28 位的 Path History Register for Branch(PHRB)，每次执行 taken branch 时更新</li>\n<li>更新方式为：<code>PHRTnew = (PHRTold &lt;&lt; 1) xor T[31:2], PHRBnew = (PHRBold &lt;&lt; 1) xor B[5:2]</code>，其中 B 代表分支指令的地址，T 代表分支跳转的目的地址</li>\n</ol>\n<p>Blizzard 的分支预测器与 Apple M1 Icestorm 相同，采用的历史更新方式为：</p>\n<ol>\n<li>使用 60 位的 Path History Register for Target(PHRT) 以及 16 位的 Path History Register for Branch(PHRB)，每次执行 taken branch 时更新</li>\n<li>更新方式为：<code>PHRTnew = (PHRTold &lt;&lt; 1) xor T[47:2], PHRBnew = (PHRBold &lt;&lt; 1) xor B[5:2]</code>，其中 B 代表分支指令的地址，T 代表分支跳转的目的地址</li>\n</ol>\n<p>各厂商处理器的 PHR 更新规则见 <a href=\"https://jia.je/cpu/cbp.html\">jiegec/cpu</a>。</p>\n<h2 id=\"后端\">后端</h2>\n<h3 id=\"物理寄存器堆\">物理寄存器堆</h3>\n<h4 id=\"avalanche_5\">Avalanche</h4>\n<p>为了测试物理寄存器堆的大小，一般会用两个依赖链很长的操作放在开头和结尾，中间填入若干个无关的指令，并且用这些指令来耗费物理寄存器堆。Avalanche 测试结果见下图：</p>\n<p><img alt=\"\" src=\"../../../../apple-m2-avalanche-prf.png\" /></p>\n<ul>\n<li>32b/64b int：测试 speculative 32/64 位整数寄存器的数量，拐点在 362</li>\n<li>32b fp：测试 speculative 32 位浮点寄存器的数量，拐点在 356</li>\n<li>flags：测试 speculative NZCV 寄存器的数量，拐点在 123</li>\n</ul>\n<p>Avalanche 寄存器堆容量和 Firestorm 类似，没有 M4 的双倍 32b int 寄存器优化。</p>\n<h4 id=\"blizzard_5\">Blizzard</h4>\n<p>Blizzard 测试结果如下：</p>\n<p><img alt=\"\" src=\"../../../../apple-m2-blizzard-prf.png\" /></p>\n<ul>\n<li>32b/64b int：测试 speculative 32/64 位整数寄存器的数量，拐点在 86</li>\n<li>32b fp：测试 speculative 32 位浮点寄存器的数量，拐点在 80</li>\n<li>flags：测试 speculative NZCV 寄存器的数量，拐点在 46</li>\n</ul>\n<p>相比 M1 Icestorm 有少量的扩容。</p>\n<p>注意这里测试的都是能够用于预测执行的寄存器数量，实际的物理寄存器堆还需要保存架构寄存器。但具体保存多少个架构寄存器不确定，但至少 32 个整数通用寄存器和浮点寄存器是一定有的，但可能还有一些额外的需要重命名的状态也要算进来。</p>\n<p><a href=\"https://github.com/jiegec/cpu-micro-benchmarks/blob/master/src/register_file_size_gen.cpp\">测试过程详见测试代码</a>。</p>\n<h3 id=\"load-store-unit--l1-dcache\">Load Store Unit + L1 DCache</h3>\n<h4 id=\"l1-dcache-容量\">L1 DCache 容量</h4>\n<p>官方信息：根据 Apple Silicon CPU Optimization Guide，从 M1 Family 到 M4 Family，从 A14 Bionic 到 A18 Family，P-Core 的 L1 DCache 都是 128KiB, 8-way, 64B lines 的配置，E-Core 的 L1 DCache 都是 64KiB, 8-way, 64B lines 的配置。</p>\n<h5 id=\"avalanche_6\">Avalanche</h5>\n<p>构造不同大小 footprint 的 pointer chasing 链，测试不同 footprint 下每条 load 指令耗费的时间，Avalanche 上的结果：</p>\n<p><img alt=\"\" src=\"../../../../apple-m2-avalanche-l1dc.png\" /></p>\n<p>可以看到 128KB 出现了拐点，对应的就是 128KB 的 L1 DCache 容量，和官方信息一致。当 footprint 比较小的时候，由于 Load Address Predictor 的介入，打破了依赖链，所以出现了 latency 小于正常 load to use 的 3 cycle latency 的情况。</p>\n<h5 id=\"blizzard_6\">Blizzard</h5>\n<p>Blizzard 上的结果：</p>\n<p><img alt=\"\" src=\"../../../../apple-m2-blizzard-l1dc.png\" /></p>\n<p>可以看到 64KB 出现了明显的拐点，对应的就是 64KB 的 L1 DCache 容量，和官方信息一致。L1 DCache 范围内延迟是 3 cycle。由此可见 Blizzard 没有 Load Address Predictor，不能打断依赖链。</p>\n<p><a href=\"https://github.com/jiegec/cpu-micro-benchmarks/blob/master/src/memory_latency.cpp\">测试过程详见测试代码</a>。</p>\n<h4 id=\"l1-dtlb-容量\">L1 DTLB 容量</h4>\n<p>官方信息：根据 Apple Silicon CPU Optimization Guide，对于 P-Core 来说，除了 M2 Family、A14 Bionic 和 A15 Bionic 的 L1 DTLB 是 256 entries 以外，其余的 M1 Family、M3 Family 到 M4 Family，A16 Bionic 到 A18 Family 的 L1 DTLB 都是 160 entries。对于 E-Core 来说，除了 M1 Family 和 A14 Bionic 是 128 entries，其余的从 M2 Family 到 M4 Family，A15 Bionic 到 A18 Family 都是 192 entries。</p>\n<p>因此，Avalanche L1 DTLB 容量是 256，Blizzard L1 DTLB 容量是 192。</p>\n<h5 id=\"avalanche_7\">Avalanche</h5>\n<p>用类似的方法测试 L1 DTLB 容量，只不过这次 pointer chasing 链的指针分布在不同的 page 上，使得 DTLB 成为瓶颈，在 Avalanche 上：</p>\n<p><img alt=\"\" src=\"../../../../apple-m2-avalanche-l1dtlb.png\" /></p>\n<p>从 256 个页开始性能下降，认为 Avalanche 的 L1 DTLB 有 256 项，和官方信息一致。性能出现波动，有时候能实现 1 cycle 的 CPI，主要来自于 Load Address Predictor。</p>\n<h5 id=\"blizzard_7\">Blizzard</h5>\n<p>Blizzard:</p>\n<p><img alt=\"\" src=\"../../../../apple-m2-blizzard-l1dtlb.png\" /></p>\n<p>从 192 个页开始性能下降，认为 Blizzard 的 L1 DTLB 有 192 项，和官方信息一致。</p>\n<p><a href=\"https://github.com/jiegec/cpu-micro-benchmarks/blob/master/src/dtlb_size.cpp\">测试过程详见测试代码</a>。</p>\n<h4 id=\"loadstore-带宽\">Load/Store 带宽</h4>\n<h5 id=\"avalanche_8\">Avalanche</h5>\n<p>针对 Load Store 带宽，实测 Avalanche 每个周期可以完成：</p>\n<ul>\n<li>3x 128b Load + 1x 128b Store</li>\n<li>2x 128b Load + 2x 128b Store</li>\n<li>1x 128b Load + 2x 128b Store</li>\n<li>2x 128b Store</li>\n</ul>\n<p>如果把每条指令的访存位宽从 128b 改成 256b，读写带宽不变，指令吞吐减半。也就是说最大的读带宽是 48B/cyc，最大的写带宽是 32B/cyc，二者不能同时达到。和 M1/M4 的 P-Core 相同。</p>\n<h5 id=\"blizzard_8\">Blizzard</h5>\n<p>实测 Blizzard 每个周期可以完成：</p>\n<ul>\n<li>2x 128b Load</li>\n<li>1x 128b Load + 1x 128b Store</li>\n<li>1x 128b Store</li>\n</ul>\n<p>如果把每条指令的访存位宽从 128b 改成 256b，读写带宽不变，指令吞吐减半。也就是说最大的读带宽是 32B/cyc，最大的写带宽是 16B/cyc，二者不能同时达到。和 M1/M4 的 E-Core 相同。</p>\n<h4 id=\"memory-dependency-predictor\">Memory Dependency Predictor</h4>\n<p>为了预测执行 Load，需要保证 Load 和之前的 Store 访问的内存没有 Overlap，那么就需要有一个预测器来预测 Load 和 Store 之前在内存上的依赖。参考 <a href=\"https://blog.stuffedcow.net/2014/01/x86-memory-disambiguation/\">Store-to-Load Forwarding and Memory Disambiguation in x86 Processors</a> 的方法，构造两个指令模式，分别在地址和数据上有依赖：</p>\n<ul>\n<li>数据依赖，地址无依赖：<code>str x3, [x1]</code> 和 <code>ldr x3, [x2]</code></li>\n<li>地址依赖，数据无依赖：<code>str x2, [x1]</code> 和 <code>ldr x1, [x2]</code></li>\n</ul>\n<p>初始化时，<code>x1</code> 和 <code>x2</code> 指向同一个地址，重复如上的指令模式，观察到多少条 <code>ldr</code> 指令时会出现性能下降。</p>\n<h5 id=\"avalanche_9\">Avalanche</h5>\n<p>在 Avalanche 上测试：</p>\n<p><img alt=\"\" src=\"../../../../apple-m2-avalanche-memory-dependency-predictor.png\" /></p>\n<p>数据依赖没有明显的阈值，但从 77 开始出现了一个小的增长，且斜率不为零；地址依赖的阈值是 62。相比 M1 P-Core Firestorm 有所减小。</p>\n<h5 id=\"blizzard_9\">Blizzard</h5>\n<p>Blizzard:</p>\n<p><img alt=\"\" src=\"../../../../apple-m2-blizzard-memory-dependency-predictor.png\" /></p>\n<p>数据依赖的阈值是 10，地址依赖的阈值是 16。和 Icestorm 差不多。</p>\n<h4 id=\"store-to-load-forwarding\">Store to Load Forwarding</h4>\n<h5 id=\"avalanche_10\">Avalanche</h5>\n<p>经过实际测试，Avalanche 上如下的情况可以成功转发，对地址 x 的 Store 转发到对地址 y 的 Load 成功时 y-x 的取值范围：</p>\n<table>\n<thead>\n<tr>\n<th>Store\\Load</th>\n<th>8b Load</th>\n<th>16b Load</th>\n<th>32b Load</th>\n<th>64b Load</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>8b Store</td>\n<td>{0}</td>\n<td>[-1,0]</td>\n<td>[-3,0]</td>\n<td>[-7,0]</td>\n</tr>\n<tr>\n<td>16b Store</td>\n<td>[0,1]</td>\n<td>[-1,1]</td>\n<td>[-3,1]</td>\n<td>[-7,1]</td>\n</tr>\n<tr>\n<td>32b Store</td>\n<td>[0,3]</td>\n<td>[-1,3]</td>\n<td>[-3,3]</td>\n<td>[-7,3]</td>\n</tr>\n<tr>\n<td>64b Store</td>\n<td>[0,7]</td>\n<td>[-1,7]</td>\n<td>[-3,7]</td>\n<td>[-7,7]</td>\n</tr>\n</tbody>\n</table>\n<p>从上表可以看到，所有 Store 和 Load Overlap 的情况，无论地址偏移，都能成功转发。甚至在 Load 或 Store 跨越 64B 缓存行边界时，也可以成功转发，代价是多一个周期。</p>\n<p>一个 Load 需要转发两个、四个甚至八个 Store 的数据时，如果数据跨越缓存行，则不能转发，但其他情况下，无论地址偏移，都可以转发，只是比从单个 Store 转发需要多耗费 1-4 个周期。</p>\n<p>成功转发时 7.3 cycle，跨缓存行且转发失败时 26+ cycle。和 Firestorm 具有相同的性能。</p>\n<p>小结：Apple Avalanche 的 Store to Load Forwarding：</p>\n<ul>\n<li>1 ld + 1 st: 支持</li>\n<li>1 ld + 2 st: 支持，要求不跨越 64B 边界</li>\n<li>1 ld + 4 st: 支持，要求不跨越 64B 边界</li>\n<li>1 ld + 8 st: 支持，要求不跨越 64B 边界</li>\n</ul>\n<h5 id=\"blizzard_10\">Blizzard</h5>\n<p>在 Blizzard 上，如果 Load 和 Store 访问范围出现重叠，则需要 10 Cycle，无论是和几个 Store 重叠，也无论是否跨缓存行。和 Icestorm 行为相同。</p>\n<h4 id=\"load-to-use-latency\">Load to use latency</h4>\n<p>官方信息：根据 Apple Silicon CPU Optimization Guide，Apple 实现了 fast pointer chasing with a 3-cycle latency，要求后一个 load 的 base register 和前一个 load 的 destination register 相同。</p>\n<h5 id=\"avalanche_11\">Avalanche</h5>\n<p>实测 Avalanche 的 Load to use latency 针对 pointer chasing 场景做了优化，在下列的场景下可以达到 3 cycle:</p>\n<ul>\n<li><code>ldr x0, [x0]</code>: load 结果转发到基地址，无偏移</li>\n<li><code>ldr x0, [x0, 8]</code>：load 结果转发到基地址，有立即数偏移</li>\n<li><code>ldr x0, [x0, x1]</code>：load 结果转发到基地址，有寄存器偏移</li>\n<li><code>ldp x0, x1, [x0]</code>：load pair 的第一个目的寄存器转发到基地址，无偏移</li>\n</ul>\n<p>如果访存跨越了 8B 边界，则退化到 4 cycle。</p>\n<p>在下列场景下 Load to use latency 则是 4 cycle：</p>\n<ul>\n<li>load 的目的寄存器作为 alu 的源寄存器（下称 load to alu latency）</li>\n<li><code>ldr x0, [sp, x0, lsl #3]</code>：load 结果转发到 index</li>\n<li><code>ldp x1, x0, [x0]</code>：load pair 的第二个目的寄存器转发到基地址，无偏移</li>\n</ul>\n<p>注意由于 Load Address Predictor 的存在，测试的时候需要排除预测器带来的影响。延迟方面，和 M1/M4 P-Core 相同。</p>\n<h5 id=\"blizzard_11\">Blizzard</h5>\n<p>实测 Blizzard 的 Load to use latency 针对 pointer chasing 场景做了优化，在下列的场景下可以达到 3 cycle:</p>\n<ul>\n<li><code>ldr x0, [x0]</code>: load 结果转发到基地址，无偏移</li>\n<li><code>ldr x0, [x0, 8]</code>：load 结果转发到基地址，有立即数偏移</li>\n<li><code>ldr x0, [x0, x1]</code>：load 结果转发到基地址，有寄存器偏移</li>\n<li><code>ldp x0, x1, [x0]</code>：load pair 的第一个目的寄存器转发到基地址，无偏移</li>\n</ul>\n<p>如果访存跨越了 8B/16B/32B 边界，依然是 3 cycle；跨越了 64B 边界则退化到 7 cycle。</p>\n<p>在下列场景下 Load to use latency 则是 4 cycle：</p>\n<ul>\n<li>load 的目的寄存器作为 alu 的源寄存器（下称 load to alu latency）</li>\n<li><code>ldr x0, [sp, x0, lsl #3]</code>：load 结果转发到 index</li>\n<li><code>ldp x1, x0, [x0]</code>：load pair 的第二个目的寄存器转发到基地址，无偏移</li>\n</ul>\n<p>延迟方面，和 M1/M4 E-Core 相同。</p>\n<h4 id=\"virtual-address-utagway-predictor\">Virtual Address UTag/Way-Predictor</h4>\n<p>Linear Address UTag/Way-Predictor 是 AMD 的叫法，但使用相同的测试方法，也可以在 Apple M2 上观察到类似的现象，猜想它也用了类似的基于虚拟地址的 UTag/Way Predictor 方案，并测出来它的 UTag 也有 8 bit，Avalanche 和 Blizzard 都是相同的：</p>\n<ul>\n<li>VA[14] xor VA[22] xor VA[30] xor VA[38] xor VA[46]</li>\n<li>VA[15] xor VA[23] xor VA[31] xor VA[39] xor VA[47]</li>\n<li>VA[16] xor VA[24] xor VA[32] xor VA[40]</li>\n<li>VA[17] xor VA[25] xor VA[33] xor VA[41]</li>\n<li>VA[18] xor VA[26] xor VA[34] xor VA[42]</li>\n<li>VA[19] xor VA[27] xor VA[35] xor VA[43]</li>\n<li>VA[20] xor VA[28] xor VA[36] xor VA[44]</li>\n<li>VA[21] xor VA[29] xor VA[37] xor VA[45]</li>\n</ul>\n<p>一共有 8 bit，由 VA[47:14] 折叠而来。和 Apple M1/M4 相同。</p>\n<h3 id=\"执行单元\">执行单元</h3>\n<p>想要测试有多少个执行单元，每个执行单元可以运行哪些指令，首先要测试各类指令在无依赖情况下的 IPC，通过 IPC 来推断有多少个能够执行这类指令的执行单元；但由于一个执行单元可能可以执行多类指令，于是进一步需要观察在混合不同类的指令时的 IPC，从而推断出完整的结果。</p>\n<p>官方信息：根据 Apple Silicon CPU Optimization Guide，M2 Family 的 P-Core Avalanche 包括如下计算单元：</p>\n<ol>\n<li>ALU/f, BRc/i</li>\n<li>ALU/f, BRc</li>\n<li>ALU/f</li>\n<li>ALU, MUL, MAC, MISC</li>\n<li>ALU, MUL, DIV</li>\n<li>ALU</li>\n<li>GENERAL, MOVE2GPR, FCMPf, FCSELf, FDIV, MUL, SHA</li>\n<li>GENERAL, MOVE2GPR, FCSELf, MUL</li>\n<li>GENERAL, MUL</li>\n<li>GENERAL, MUL</li>\n</ol>\n<p>P-Core Avalanche 访存：</p>\n<ul>\n<li>Burst: 3 load uops, 2 store uops (address part), and 2 store uops (data part)<ul>\n<li>即 3 load, 2 sta, 2 std</li>\n</ul>\n</li>\n<li>Sustained: 4 uops, 2 write into the cache</li>\n</ul>\n<p>M2 Family 的 E-Core Blizzard 包括如下计算单元：</p>\n<ol>\n<li>ALU/f, MUL, MAC, MISC</li>\n<li>ALU/f, BRi, DIV</li>\n<li>ALU/f, BRc</li>\n<li>ALU/f</li>\n<li>GENERAL, MOVE2GPR, FCMPf, FCSELf, FDIV, MUL, SHA</li>\n<li>GENERAL, FCSELf, MUL</li>\n</ol>\n<p>E-Core Blizzard 访存：</p>\n<ul>\n<li>Burst: 2 load uops, or 2 store uops (address part), or 1 of each, along with 2 store uops (data part)<ul>\n<li>即 2 load，或者 2 sta，或者 1 load + 1 std，或者 1 sta + 1 std</li>\n</ul>\n</li>\n<li>Sustained: 2 uops, 1 write into the cache</li>\n</ul>\n<p>和 M1 一样。</p>\n<h4 id=\"avalanche_12\">Avalanche</h4>\n<p>在 Avalanche 上测试如下各类指令的延迟和每周期吞吐：</p>\n<table>\n<thead>\n<tr>\n<th>指令</th>\n<th>延迟</th>\n<th>吞吐</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>asimd int add</td>\n<td>2</td>\n<td>4</td>\n</tr>\n<tr>\n<td>asimd aesd/aese</td>\n<td>3</td>\n<td>4</td>\n</tr>\n<tr>\n<td>asimd aesimc/aesmc</td>\n<td>2</td>\n<td>4</td>\n</tr>\n<tr>\n<td>asimd fabs</td>\n<td>2</td>\n<td>4</td>\n</tr>\n<tr>\n<td>asimd fadd</td>\n<td>3</td>\n<td>4</td>\n</tr>\n<tr>\n<td>asimd fdiv 64b</td>\n<td>10</td>\n<td>1</td>\n</tr>\n<tr>\n<td>asimd fdiv 32b</td>\n<td>8</td>\n<td>1</td>\n</tr>\n<tr>\n<td>asimd fmax</td>\n<td>2</td>\n<td>4</td>\n</tr>\n<tr>\n<td>asimd fmin</td>\n<td>2</td>\n<td>4</td>\n</tr>\n<tr>\n<td>asimd fmla</td>\n<td>4</td>\n<td>4</td>\n</tr>\n<tr>\n<td>asimd fmul</td>\n<td>4</td>\n<td>4</td>\n</tr>\n<tr>\n<td>asimd fneg</td>\n<td>2</td>\n<td>4</td>\n</tr>\n<tr>\n<td>asimd frecpe</td>\n<td>3</td>\n<td>1</td>\n</tr>\n<tr>\n<td>asimd frsqrte</td>\n<td>3</td>\n<td>1</td>\n</tr>\n<tr>\n<td>asimd fsqrt 64b</td>\n<td>13</td>\n<td>0.5</td>\n</tr>\n<tr>\n<td>asimd fsqrt 32b</td>\n<td>10</td>\n<td>0.5</td>\n</tr>\n<tr>\n<td>fp cvtf2i (fcvtzs)</td>\n<td>-</td>\n<td>2</td>\n</tr>\n<tr>\n<td>fp cvti2f (scvtf)</td>\n<td>-</td>\n<td>3</td>\n</tr>\n<tr>\n<td>fp fabs</td>\n<td>2</td>\n<td>4</td>\n</tr>\n<tr>\n<td>fp fadd</td>\n<td>3</td>\n<td>4</td>\n</tr>\n<tr>\n<td>fp fdiv 64b</td>\n<td>10</td>\n<td>1</td>\n</tr>\n<tr>\n<td>fp fdiv 32b</td>\n<td>8</td>\n<td>1</td>\n</tr>\n<tr>\n<td>fp fjcvtzs</td>\n<td>-</td>\n<td>1</td>\n</tr>\n<tr>\n<td>fp fmax</td>\n<td>2</td>\n<td>4</td>\n</tr>\n<tr>\n<td>fp fmin</td>\n<td>2</td>\n<td>4</td>\n</tr>\n<tr>\n<td>fp fmov f2i</td>\n<td>-</td>\n<td>2</td>\n</tr>\n<tr>\n<td>fp fmov i2f</td>\n<td>-</td>\n<td>3</td>\n</tr>\n<tr>\n<td>fp fmul</td>\n<td>4</td>\n<td>4</td>\n</tr>\n<tr>\n<td>fp fneg</td>\n<td>2</td>\n<td>4</td>\n</tr>\n<tr>\n<td>fp frecpe</td>\n<td>3</td>\n<td>1</td>\n</tr>\n<tr>\n<td>fp frecpx</td>\n<td>3</td>\n<td>1</td>\n</tr>\n<tr>\n<td>fp frsqrte</td>\n<td>3</td>\n<td>1</td>\n</tr>\n<tr>\n<td>fp fsqrt 64b</td>\n<td>13</td>\n<td>0.5</td>\n</tr>\n<tr>\n<td>fp fsqrt 32b</td>\n<td>10</td>\n<td>0.5</td>\n</tr>\n<tr>\n<td>int add</td>\n<td>1</td>\n<td>4.4</td>\n</tr>\n<tr>\n<td>int addi</td>\n<td>1</td>\n<td>6</td>\n</tr>\n<tr>\n<td>int bfm</td>\n<td>1</td>\n<td>1</td>\n</tr>\n<tr>\n<td>int crc</td>\n<td>3</td>\n<td>1</td>\n</tr>\n<tr>\n<td>int csel</td>\n<td>1</td>\n<td>3</td>\n</tr>\n<tr>\n<td>int madd (addend)</td>\n<td>1</td>\n<td>1</td>\n</tr>\n<tr>\n<td>int madd (others)</td>\n<td>3</td>\n<td>1</td>\n</tr>\n<tr>\n<td>int mrs nzcv</td>\n<td>-</td>\n<td>2</td>\n</tr>\n<tr>\n<td>int mul</td>\n<td>3</td>\n<td>2</td>\n</tr>\n<tr>\n<td>int nop</td>\n<td>-</td>\n<td>9.5</td>\n</tr>\n<tr>\n<td>int sbfm</td>\n<td>1</td>\n<td>4.5</td>\n</tr>\n<tr>\n<td>int sdiv</td>\n<td>7/8</td>\n<td>0.5</td>\n</tr>\n<tr>\n<td>int smull</td>\n<td>3</td>\n<td>2</td>\n</tr>\n<tr>\n<td>int ubfm</td>\n<td>1</td>\n<td>4.6</td>\n</tr>\n<tr>\n<td>int udiv</td>\n<td>7/8</td>\n<td>0.5</td>\n</tr>\n<tr>\n<td>not taken branch</td>\n<td>-</td>\n<td>2</td>\n</tr>\n<tr>\n<td>taken branch</td>\n<td>-</td>\n<td>1</td>\n</tr>\n<tr>\n<td>mem asimd load</td>\n<td>-</td>\n<td>3</td>\n</tr>\n<tr>\n<td>mem asimd store</td>\n<td>-</td>\n<td>2</td>\n</tr>\n<tr>\n<td>mem int load</td>\n<td>-</td>\n<td>3</td>\n</tr>\n<tr>\n<td>mem int store</td>\n<td>-</td>\n<td>2</td>\n</tr>\n</tbody>\n</table>\n<p>测试结果与 <a href=\"../../../../2024/12/26/apple-m1/\">M1 Firestorm</a> 基本一样，这里就不再进行深入分析。</p>\n<h4 id=\"blizzard_12\">Blizzard</h4>\n<p>接下来用类似的方法测试 Blizzard：</p>\n<table>\n<thead>\n<tr>\n<th>指令</th>\n<th>延迟</th>\n<th>吞吐</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>asimd int add</td>\n<td>2</td>\n<td>2</td>\n</tr>\n<tr>\n<td>asimd aesd/aese</td>\n<td>3</td>\n<td>2</td>\n</tr>\n<tr>\n<td>asimd aesimc/aesmc</td>\n<td>2</td>\n<td>2</td>\n</tr>\n<tr>\n<td>asimd fabs</td>\n<td>2</td>\n<td>2</td>\n</tr>\n<tr>\n<td>asimd fadd</td>\n<td>3</td>\n<td>2</td>\n</tr>\n<tr>\n<td>asimd fdiv 64b</td>\n<td>11</td>\n<td>0.5</td>\n</tr>\n<tr>\n<td>asimd fdiv 32b</td>\n<td>9</td>\n<td>0.5</td>\n</tr>\n<tr>\n<td>asimd fmax</td>\n<td>2</td>\n<td>2</td>\n</tr>\n<tr>\n<td>asimd fmin</td>\n<td>2</td>\n<td>2</td>\n</tr>\n<tr>\n<td>asimd fmla</td>\n<td>4</td>\n<td>2</td>\n</tr>\n<tr>\n<td>asimd fmul</td>\n<td>4</td>\n<td>2</td>\n</tr>\n<tr>\n<td>asimd fneg</td>\n<td>2</td>\n<td>2</td>\n</tr>\n<tr>\n<td>asimd frecpe</td>\n<td>4</td>\n<td>0.5</td>\n</tr>\n<tr>\n<td>asimd frsqrte</td>\n<td>4</td>\n<td>0.5</td>\n</tr>\n<tr>\n<td>asimd fsqrt 64b</td>\n<td>15</td>\n<td>0.5</td>\n</tr>\n<tr>\n<td>asimd fsqrt 32b</td>\n<td>12</td>\n<td>0.5</td>\n</tr>\n<tr>\n<td>fp cvtf2i (fcvtzs)</td>\n<td>-</td>\n<td>1</td>\n</tr>\n<tr>\n<td>fp cvti2f (scvtf)</td>\n<td>-</td>\n<td>2</td>\n</tr>\n<tr>\n<td>fp fabs</td>\n<td>2</td>\n<td>2</td>\n</tr>\n<tr>\n<td>fp fadd</td>\n<td>3</td>\n<td>2</td>\n</tr>\n<tr>\n<td>fp fdiv 64b</td>\n<td>10</td>\n<td>1</td>\n</tr>\n<tr>\n<td>fp fdiv 32b</td>\n<td>8</td>\n<td>1</td>\n</tr>\n<tr>\n<td>fp fjcvtzs</td>\n<td>-</td>\n<td>0.5</td>\n</tr>\n<tr>\n<td>fp fmax</td>\n<td>2</td>\n<td>2</td>\n</tr>\n<tr>\n<td>fp fmin</td>\n<td>2</td>\n<td>2</td>\n</tr>\n<tr>\n<td>fp fmov f2i</td>\n<td>-</td>\n<td>1</td>\n</tr>\n<tr>\n<td>fp fmov i2f</td>\n<td>-</td>\n<td>2</td>\n</tr>\n<tr>\n<td>fp fmul</td>\n<td>4</td>\n<td>2</td>\n</tr>\n<tr>\n<td>fp fneg</td>\n<td>2</td>\n<td>2</td>\n</tr>\n<tr>\n<td>fp frecpe</td>\n<td>3</td>\n<td>1</td>\n</tr>\n<tr>\n<td>fp frecpx</td>\n<td>3</td>\n<td>1</td>\n</tr>\n<tr>\n<td>fp frsqrte</td>\n<td>3</td>\n<td>1</td>\n</tr>\n<tr>\n<td>fp fsqrt 64b</td>\n<td>13</td>\n<td>0.5</td>\n</tr>\n<tr>\n<td>fp fsqrt 32b</td>\n<td>10</td>\n<td>0.5</td>\n</tr>\n<tr>\n<td>int add</td>\n<td>1</td>\n<td>4</td>\n</tr>\n<tr>\n<td>int addi</td>\n<td>1</td>\n<td>4</td>\n</tr>\n<tr>\n<td>int bfm</td>\n<td>1</td>\n<td>1</td>\n</tr>\n<tr>\n<td>int crc</td>\n<td>3</td>\n<td>1</td>\n</tr>\n<tr>\n<td>int csel</td>\n<td>1</td>\n<td>4</td>\n</tr>\n<tr>\n<td>int madd (addend)</td>\n<td>1</td>\n<td>1</td>\n</tr>\n<tr>\n<td>int madd (others)</td>\n<td>3</td>\n<td>1</td>\n</tr>\n<tr>\n<td>int mrs nzcv</td>\n<td>-</td>\n<td>4</td>\n</tr>\n<tr>\n<td>int mul</td>\n<td>3</td>\n<td>1</td>\n</tr>\n<tr>\n<td>int nop</td>\n<td>-</td>\n<td>5</td>\n</tr>\n<tr>\n<td>int sbfm</td>\n<td>1</td>\n<td>4</td>\n</tr>\n<tr>\n<td>int sdiv</td>\n<td>7</td>\n<td>0.125=1/8</td>\n</tr>\n<tr>\n<td>int smull</td>\n<td>3</td>\n<td>1</td>\n</tr>\n<tr>\n<td>int ubfm</td>\n<td>1</td>\n<td>4</td>\n</tr>\n<tr>\n<td>int udiv</td>\n<td>7</td>\n<td>0.125=1/8</td>\n</tr>\n<tr>\n<td>not taken branch</td>\n<td>-</td>\n<td>2</td>\n</tr>\n<tr>\n<td>taken branch</td>\n<td>-</td>\n<td>1</td>\n</tr>\n<tr>\n<td>mem asimd load</td>\n<td>-</td>\n<td>2</td>\n</tr>\n<tr>\n<td>mem asimd store</td>\n<td>-</td>\n<td>1</td>\n</tr>\n<tr>\n<td>mem int load</td>\n<td>-</td>\n<td>2</td>\n</tr>\n<tr>\n<td>mem int store</td>\n<td>-</td>\n<td>1</td>\n</tr>\n</tbody>\n</table>\n<p>测试结果与 <a href=\"../../../../2024/12/26/apple-m1/\">M1 Icestorm</a> 基本一样，只是多了一个 ALU，所以部分整数指令的 IPC 加一，其他则基本一样，这里就不再进行深入分析。</p>\n<h3 id=\"reorder-buffer\">Reorder Buffer</h3>\n<h4 id=\"avalanche_13\">Avalanche</h4>\n<p>首先用不同数量的 fsqrt 依赖链加 NOP 指令测试 Avalanche 的 ROB 大小：</p>\n<p><img alt=\"\" src=\"../../../../apple-m2-avalanche-rob.png\" /></p>\n<p>可以看到当 fsqrt 数量足够多的时候，出现了统一的拐点，在 2022 条指令左右。</p>\n<p>为了测 Coalesced ROB 的大小，改成用 load/store 指令，可以测到拐点在 292 左右：</p>\n<p><img alt=\"\" src=\"../../../../apple-m2-avalanche-rob-load.png\" /></p>\n<p>2022 除以 292 约等于 7，意味着每个 group 可以保存 7 条指令，一共有 289 左右个 group。相比 M1 P-Core Firestorm，Group 数量有所减少。</p>\n<h4 id=\"blizzard_13\">Blizzard</h4>\n<p>首先用 NOP 指令测试 Blizzard 的 ROB 大小：</p>\n<p><img alt=\"\" src=\"../../../../apple-m2-blizzard-rob.png\" /></p>\n<p>可以看到拐点是 486 条指令。</p>\n<p>为了测 Coalesced ROB 的大小，改成用 load/store 指令，可以测到拐点在 74 左右：</p>\n<p><img alt=\"\" src=\"../../../../apple-m2-blizzard-rob-load.png\" /></p>\n<p>但是 486 除以 74 是 6.57，离 6 或者 7 都有一段距离，比较奇怪，不确定每个 group 可以放多少条指令。容量上比 M1 E-Core 有提升。</p>\n<h3 id=\"l2-cache\">L2 Cache</h3>\n<p>官方信息：根据 Apple Silicon CPU Optimization Guide，L2 Cache 配置如下：</p>\n<ul>\n<li>M1 Family/A14 Bionic: P-Core cluster 12MiB, 12-way, 128B lines; E-Core cluster 4MiB, 16-way, 128B lines</li>\n<li>M2/M3/M4 Family/A16 Bionic/A17 Pro/A18 Pro: P-Core cluster 16MiB, 16-way, 128B lines; E-Core cluster 4MiB, 16-way, 128B lines</li>\n<li>A14 Bionic/A18: P-Core cluster 8MiB, 16-way, 128B lines; E-Core cluster 4MiB, 16-way, 128B lines</li>\n</ul>\n<h3 id=\"memory-cache\">Memory Cache</h3>\n<p>官方信息：根据 Apple Silicon CPU Optimization Guide，Memory Cache（在别的处理器也叫 System Level Cache，就是 Last Level Cache）的配置如下：</p>\n<ul>\n<li>M1/M2/M3/M4: 8MiB, 16-way, 128B lines</li>\n<li>M3 Pro/A18: 12MiB, 16-way, 128B lines</li>\n<li>A14 Bionic: 16MiB, 16-way, 128B lines</li>\n<li>M1 Pro/M2 Pro/M4 Pro/A16 Bionic/A17 Pro/A18 Pro: 24MiB, 12-way, 128B lines</li>\n<li>A15 Bionic: 32MiB, 16-way, 128B lines</li>\n<li>M1 Max/M2 Max/M3 Max/M4 Max: 48MiB, 12-way, 128B lines</li>\n<li>M1 Ultra/M2 Ultra/M3 Ultra: 96MiB, 12-way, 128B lines</li>\n</ul>\n<h3 id=\"l2-tlb\">L2 TLB</h3>\n<p>官方信息：根据 Apple Silicon CPU Optimization Guide，P-Core 的 L2 TLB 容量，从 M1 Family 到 M4 Family，从 A14 Bionic 到 A18 Family，都是 3072 entries；E-Core 的 L2 TLB 容量，M1 Family 和 A14 Bionic 是 1024 entries，M2 Family 到 M4 Family 和 A15 Bionic 到 A18 Family 都是 2048 entries。</p>\n<h2 id=\"总结\">总结</h2>\n<p>M2 相比 M1，在很多方面做了迭代：</p>\n<ol>\n<li>P-Core 的前端改进了 BTB，多加了一级 BTB</li>\n<li>E-Core 的宽度从 4 提升到 5，整数执行单元增加</li>\n<li>引入了 Load Address Predictor（P-Core）</li>\n<li>缓存和 TLB 容量增加</li>\n</ol>\n<p>指令集扩展方面，M2 增加了 i8mm bf16 bti ecv 的 feature。在 SPEC CPU 2017 Rate-1 上，M2 P-Core 相比 M1 P-Core 有 16% 的整数性能提升和 9% 的浮点性能提升，而 M2 E-Core 相比 M1 E-Core 有 33% 的整数性能提升和 31% 的浮点性能提升。</p>","date_modified":"2026-07-06T00:00:00+00:00","date_published":"2026-07-06T00:00:00+00:00","id":"https://jia.je/hardware/2026/07/06/apple-m2/","image":null,"tags":["apple","cpu","hardware","m2","performance","uarch-review"],"title":"Apple M2 (Avalanche &amp; Blizzard) 微架构评测","url":"https://jia.je/hardware/2026/07/06/apple-m2/"},{"authors":[],"content_html":"<h1 id=\"arm-neoverse-v3-代号-poseidon-微架构评测\">ARM Neoverse V3 (代号 Poseidon) 微架构评测</h1>\n<h2 id=\"背景\">背景</h2>\n<p>使用 ARM Neoverse V3 核心的 AWS Graviton 5 最近<a href=\"https://aws.amazon.com/cn/blogs/aws/now-available-amazon-ec2-m9g-and-m9gd-instances-powered-by-new-aws-graviton5-processors/\">上线</a>了，相比之前的 <a href=\"../../../../2024/11/07/arm-neoverse-v2/\">Neoverse V2</a> 应该有一些改进，所以测试一下这个微架构在各个方面的表现。</p>\n<!-- more -->\n\n<h2 id=\"官方信息\">官方信息</h2>\n<p>ARM 关于 Neoverse V3 微架构有如下公开信息：</p>\n<ul>\n<li><a href=\"https://developer.arm.com/documentation/107734/0002/\">Arm® Neoverse V3 Core Technical Reference Manual</a></li>\n<li><a href=\"https://developer.arm.com/documentation/109678/300/\">Arm Neoverse V3 Software Optimization Guide</a></li>\n</ul>\n<p>Neoverse V3 与 Cortex X4 高度相似，这里也列出 Cortex X4 的相关信息：</p>\n<ul>\n<li><a href=\"https://web.archive.org/web/20250530071135/https://www.anandtech.com/show/18871/arm-unveils-armv92-mobile-architecture-cortex-x4-a720-and-a520-64bit-exclusive/2\">Arm Unveils 2023 Mobile CPU Core Designs: Cortex-X4, A720, and A520 - the Armv9.2 Family</a></li>\n<li><a href=\"https://developer.arm.com/community/arm-community-blogs/b/announcements/posts/cortex-x4-cpu-performance\">Arm Cortex-X4 advances frontiers of CPU performance</a></li>\n<li><a href=\"https://developer.arm.com/documentation/102484/0003/\">Arm® Cortex‑X4 Core Technical Reference Manual</a></li>\n</ul>\n<p>下面分模块记录官方信息和实测结果。官方信息与实测结果一致的数据会加粗。</p>\n<h2 id=\"现有评测\">现有评测</h2>\n<p>网上已经有 Neoverse V3 微架构的评测和分析，建议阅读：</p>\n<ul>\n<li><a href=\"https://mp.weixin.qq.com/s/pd6j1PwtUW9pgTNvCEzJwg\">最强 Arm 处理器 AWS Graviton5 架构剖析</a></li>\n<li><a href=\"https://mp.weixin.qq.com/s/W6gWoe9OTP4DX_9dfBMgHA\">Neoverse V3 微架构</a></li>\n</ul>\n<p>下面分各个模块分别记录官方提供的信息，以及实测的结果。读者可以对照已有的第三方评测理解。官方信息与实测结果一致的数据会加粗。</p>\n<h2 id=\"benchmark\">Benchmark</h2>\n<p>Neoverse V3 (AWS Graviton 5) 的性能测试结果见 <a href=\"../../../../../benchmark/\">SPEC</a>。</p>\n<h2 id=\"前端\">前端</h2>\n<h3 id=\"l1-icache\">L1 ICache</h3>\n<p>官方信息：<strong>64KB</strong>, 4-way set associative, VIPT behaving as PIPT, 64B cacheline, PLRU replacement policy</p>\n<p>测试 L1 ICache 容量，构造一个具有巨大指令 footprint 的循环，由大量 nop 和最后的分支指令组成，观察不同 footprint 下的 IPC：</p>\n<p><img alt=\"\" src=\"../../../../arm-neoverse-v3-fetch-bandwidth.png\" /></p>\n<p>起始 IPC 为 9。Neoverse V3 删除了 MOP Cache，不像 Neoverse V2 那样可以把两条 NOP 合并为一条 MOP 来提高 IPC。虽然是 10-wide Decode，IPC 只能到 9，应该是遇到了其他瓶颈。</p>\n<p>超出 64KB L1 ICache 后，IPC 降到 4，说明 L2 Cache 可以提供每周期 16 字节的取指带宽。</p>\n<p>L1 ICache 和 Neoverse V2 相同，只是去掉了 MOP Cache，增加了 Decode 宽度。</p>\n<h3 id=\"l1-itlb\">L1 ITLB</h3>\n<p>官方信息：Caches entries at the 4KB, 16KB, 64KB, or 2MB granularity, Fully associative, 48 entries</p>\n<p>构造一组 B 指令，分布在不同的 page 上，让 ITLB 成为瓶颈：</p>\n<p><img alt=\"\" src=\"../../../../arm-neoverse-v3-itlb-size.png\" /></p>\n<p>48 Page 处出现拐点，对应 48 项的 L1 ITLB 容量。之后性能降到 7 CPI，对应 L2 Unified TLB 的延迟。</p>\n<p>进一步增加 Page 数量，大约 1000 个页的时候，耗时从 7 cycle 逐渐上升：</p>\n<p><img alt=\"\" src=\"../../../../arm-neoverse-v3-itlb-size-l2.png\" /></p>\n<p>L2 Unified TLB 一共 2048 个 Entry，猜测 ITLB 能使用的 L2 TLB 容量只有一半，也就是 1024 项。超出后需要 Page Table Walker 做地址翻译。测试时要注意避免 Huge Page 的影响。</p>\n<p>L1 ITLB 和 Neoverse V2 行为相同。</p>\n<h3 id=\"decode\">Decode</h3>\n<p>官方信息：10-wide Decode</p>\n<p>Neoverse V3 只有一个 Decode 路径，从 ICache 过来，不再有 Neoverse V2 的 MOP Cache。</p>\n<h3 id=\"return-stack\">Return Stack</h3>\n<p>Return Stack 记录最近的函数调用链，call 时压栈，return 时弹栈，用于预测 return 指令的目的地址。构造不同深度的调用链，发现 Neoverse V3 的 Return Stack 深度为 32：</p>\n<p><img alt=\"\" src=\"../../../../arm-neoverse-v3-ras-size.png\" /></p>\n<p>大小和 Neoverse V2 相同。</p>\n<h3 id=\"btb\">BTB</h3>\n<p>构造大量 B 指令，BTB 需要记录它们的目的地址。分支数量超过 BTB 容量时，性能就会下降。将 B 指令紧密放置（每 4 字节一条）：</p>\n<p><img alt=\"\" src=\"../../../../arm-neoverse-v3-btb-size-uncond-4b.png\" /></p>\n<p>1024 条分支之前 CPI 约 0.5，说明 Neoverse V3 继承了 Neoverse V2 的 two taken 能力。之后到 8192 条分支之前 CPI 约 1，到 16384 条分支时 CPI 为 2，到 32768 条分支时 CPI 为 6。</p>\n<p>性能曲线和 Neoverse V2 相同。Neoverse V2 的 <a href=\"https://hc2023.hotchips.org/assets/program/conference/day1/CPU1/HC2023.Arm.MagnusBruce.v04.FINAL.pdf\">BTB 官方描述</a>是：</p>\n<ul>\n<li>10x larger nanoBTB（注：Neoverse V1 的 nanoBTB 是 96 entry）</li>\n<li>Split main BTB into two levels with 50% more entries（注：Neoverse V1 的 main BTB 是 8K entry）</li>\n</ul>\n<p>据此推算 Neoverse V2 和 V3 有相同的三级 BTB 结构：</p>\n<ul>\n<li>Nano BTB: 1024 branches, two taken, 1 cycle latency</li>\n<li>L1 Main BTB: 8192 branches, two taken, 2 cycle latency</li>\n<li>L2 Main BTB: 4096 branches (?)</li>\n</ul>\n<p>主要疑点是 16384 条分支时如何实现 CPI 2，目前还缺少解释。</p>\n<h3 id=\"conditional-branch-prediction\">Conditional Branch Prediction</h3>\n<p>利用我们的<a href=\"https://arxiv.org/abs/2411.13900\">逆向方法</a>，观察分支地址对 PHR 的贡献：</p>\n<p><img alt=\"\" src=\"../../../../arm-neoverse-v3-phr-branch-bits-location.png\" /></p>\n<ul>\n<li>B[2-3]: shift 263 次</li>\n<li>B[4-5]: shift 262 次</li>\n<li>B[6-7,12-13]: shift 261 次</li>\n<li>B[8-9,14-15]: shift 260 次</li>\n<li>B[10-11,16-17]: shift 259 次</li>\n</ul>\n<p>分支目的地址的贡献：</p>\n<p><img alt=\"\" src=\"../../../../arm-neoverse-v3-phr-target-bits-location.png\" /></p>\n<ul>\n<li>T[7-8]: shift 263 次</li>\n<li>T[5,9-10]: shift 262 次</li>\n<li>T[2,11]: shift 261 次</li>\n<li>T[3-4]: shift 260 次</li>\n<li>T[6]: shift 259 次</li>\n</ul>\n<p>找到对应位的异或关系后，推断出 PHR 共有 264*2=528 位，每个 taken branch 左移 2 位，footprint 从低位到高位如下：</p>\n<ul>\n<li>B[2] xor T[7]</li>\n<li>B[3] xor T[8]</li>\n<li>B[4] xor T[9]</li>\n<li>B[5] xor T[10]</li>\n<li>B[6] xor B[12] xor T[11]</li>\n<li>B[7] xor B[13] xor T[2]</li>\n<li>B[8] xor B[14] xor T[3]</li>\n<li>B[9] xor B[15] xor T[4]</li>\n<li>B[10] xor B[16]</li>\n<li>B[11] xor B[17] xor T[6]</li>\n</ul>\n<p>其中 T[5] 没有找到异或关系。和 Neoverse V2 的 PHR 构造只有很小的区别：Neoverse V2 中，T[5] shift 次数是 259。</p>\n<h2 id=\"后端\">后端</h2>\n<h3 id=\"dispatch\">Dispatch</h3>\n<p>官方信息：up to 10 MOPs per cycle and up to 20 uOPs per cycle, with the following limitations on the number of µOPs of each type that may be simultaneously dispatched:</p>\n<ul>\n<li>Up to 4 µOPs utilizing the S or B pipelines</li>\n<li>Up to 4 µOPs utilizing the M pipelines</li>\n<li>Up to 2 µOPs utilizing the M0 pipelines</li>\n<li>Up to 2 µOPs utilizing the V0 pipeline</li>\n<li>Up to 2 µOPs utilizing the V1 pipeline</li>\n<li>Up to 6 µOPs utilizing the L pipelines</li>\n</ul>\n<p>Dispatch 宽度和 Decode 对齐，不过限制不少，实际很难跑满。</p>\n<h3 id=\"物理寄存器堆\">物理寄存器堆</h3>\n<p>测试物理寄存器堆大小，用两个依赖链很长的操作放在开头和结尾，中间填入若干无关指令来耗费物理寄存器堆：</p>\n<p><img alt=\"\" src=\"../../../../arm-neoverse-v3-register-file-size.png\" /></p>\n<ul>\n<li>32b int：speculative 32 位整数寄存器，拐点约 355</li>\n<li>64b int：speculative 64 位整数寄存器，拐点约 192，只有 32b 的一半。猜测实际物理寄存器堆有 400 左右个 64 位寄存器，但可以分成两半各自当 32 位寄存器用</li>\n<li>flags：speculative NZCV 寄存器，拐点约 82</li>\n<li>32b fp：speculative 32 位浮点寄存器，观察到两次拐点，第一次和 32b int 接近，第二次和 64b int 接近</li>\n</ul>\n<h3 id=\"store-to-load-forwarding\">Store to Load Forwarding</h3>\n<p>官方信息：</p>\n<p>The Neoverse V3 core allows data to be forwarded from store instructions to a load instruction with the restrictions mentioned below:</p>\n<ul>\n<li>Load start address should align with the start or middle address of the older store</li>\n<li>Loads of size greater than or equal to 8 bytes can get the data forwarded from a maximum of 2 stores. If there are 2 stores, then each store should forward to either first or second half of the load</li>\n<li>Loads of size less than or equal to 4 bytes can get their data forwarded from only 1 store</li>\n</ul>\n<p>描述和 Neoverse V2 相同。实测以下情况可以成功转发：</p>\n<p>对地址 x 的 Store 转发到对地址 y 的 Load 成功时 y-x 的取值范围：</p>\n<table>\n<thead>\n<tr>\n<th>Store\\Load</th>\n<th>8b Load</th>\n<th>16b Load</th>\n<th>32b Load</th>\n<th>64b Load</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>8b Store</td>\n<td>{0}</td>\n<td>{}</td>\n<td>{}</td>\n<td>{}</td>\n</tr>\n<tr>\n<td>16b Store</td>\n<td>{0,1}</td>\n<td>{0}</td>\n<td>{}</td>\n<td>{}</td>\n</tr>\n<tr>\n<td>32b Store</td>\n<td>{0,2}</td>\n<td>{0,2}</td>\n<td>{0}</td>\n<td>{-4,0}</td>\n</tr>\n<tr>\n<td>64b Store</td>\n<td>{0,4}</td>\n<td>{0,4}</td>\n<td>{0,4}</td>\n<td>{-4,0,4}</td>\n</tr>\n</tbody>\n</table>\n<p>一个 Load 需要转发两个 Store 的数据的情况：对地址 x 的 32b Store 和对地址 x+4 的 32b Store 转发到对地址 y 的 64b Load，在 Overlap 的情况下，要求 y=x，前半来自第一个 Store，后半来自第二个 Store。</p>\n<p>和官方描述比较吻合，支持全部转发、转发前半、转发后半三种场景。针对常见的 64b Load，支持 y-x=-4。前半和后半也可以来自两个不同的 Store。对地址的对齐没有要求，跨缓存行边界也可以转发，只对 Load 和 Store 的相对位置有要求。转发成功时 5.3 Cycle，有 Overlap 但无法转发时 10.5 Cycle。</p>\n<p>小结：ARM Neoverse V3 的 Store to Load Forwarding：</p>\n<ul>\n<li>1 ld + 1 st: 要求 ld 和 st 地址相同或差出半个 st 宽度</li>\n<li>1 ld + 2 st: 要求 ld 和 st 地址相同</li>\n<li>1 ld + 4 st: 不支持</li>\n</ul>\n<p>和 Neoverse V2 相同。</p>\n<h3 id=\"计算单元\">计算单元</h3>\n<p>官方信息：8x ALU, <strong>3x Branch</strong>, <strong>4x 128b SIMD</strong></p>\n<p>实测以下指令的吞吐：</p>\n<ul>\n<li>int add: 6 IPC，只用到了 6 个 Single Cycle 单元，理论上两个 Multi Cycle 单元也能用上，但实际 IPC 达不到 8</li>\n<li>int mul: 2 IPC，对应两个 Multi Cycle 单元</li>\n<li>int not taken branch: 3 IPC，对应三个 Branch 单元</li>\n<li>asimd fadd double: 4 IPC，对应四个 FP/ASIMD 单元</li>\n</ul>\n<h3 id=\"load-store-unit\">Load Store Unit</h3>\n<p>官方信息：<strong>1 Load/Store Pipe + 2 Load Pipe + 1 Store Pipe</strong></p>\n<p>一个周期内最多可以完成如下 Load/Store：</p>\n<ul>\n<li>3x 64b Load</li>\n<li>2x 64b Load + 2x 64b Store</li>\n<li>1x 64b Load + 2x 64b Store</li>\n<li>2x 64b Store</li>\n</ul>\n<p>符合 1 LS + 2 LD + 1 ST pipe 的设计。相比 Neoverse V2 的 2 LS + 1 LD，同时 Load 和 Store 时性能更高。</p>\n<p>每周期通过 load/store pair 指令可以完成的 128b 访存：</p>\n<ul>\n<li>2x 128b Load</li>\n<li>2x 128b Load + 2x 128b Store</li>\n<li>1x 128b Load + 2x 128b Store</li>\n<li>2x 128b Store</li>\n</ul>\n<p>Load 没有跨越缓存行时，load to use 延迟 4 cycle；跨过 64B 缓存行边界时，增加到 5 cycle。与 Neoverse V2 相同。</p>\n<h3 id=\"memory-dependency-predictor\">Memory Dependency Predictor</h3>\n<p>为了预测执行 Load，需要确保它和之前的 Store 访问的内存没有 Overlap，所以需要一个预测器来预测这种依赖。参考 <a href=\"https://blog.stuffedcow.net/2014/01/x86-memory-disambiguation/\">Store-to-Load Forwarding and Memory Disambiguation in x86 Processors</a> 的方法，构造两种指令模式，分别测试数据和地址上的依赖：</p>\n<ul>\n<li>数据依赖，地址无依赖：<code>str x3, [x1]</code> 和 <code>ldr x3, [x2]</code></li>\n<li>地址依赖，数据无依赖：<code>str x2, [x1]</code> 和 <code>ldr x1, [x2]</code></li>\n</ul>\n<p>初始化时 <code>x1</code> 和 <code>x2</code> 指向同一个地址，重复上述模式，观察性能下降时 <code>ldr</code> 指令的数量：</p>\n<p><img alt=\"\" src=\"../../../../arm-neoverse-v3-memory-dependency-predictor-size.png\" /></p>\n<p>地址依赖的阈值是 56，数据依赖没有阈值。相比 Neoverse V2 的 40 和 Neoverse N2 的 32 有所增加。</p>\n<h3 id=\"reorder-buffer\">Reorder Buffer</h3>\n<p>把两个串行的 fsqrt 序列放在循环的头和尾，中间用 NOP 填充。如果 ROB 足够大，执行开头串行 fsqrt 序列时可以同时执行结尾的，性能最优。ROB 不够大时则会出现性能下降。</p>\n<p>测试发现大约 768 条 NOP 时出现性能下降。Neoverse V3 实现了 Instruction Fusion，两条 NOP 算做一条 uOP 和一条 MOP，所以 768 条 NOP 对应 384 MOP 的 ROB 大小。极限下 384 MOP 可以存 768 uOP，但实际很难达到，容易受限于其他结构。相比 Neoverse V2 的 320 MOP 有所增加。</p>\n<p><img alt=\"\" src=\"../../../../arm-neoverse-v3-rob-size.png\" /></p>\n<h3 id=\"l1-dcache\">L1 DCache</h3>\n<p>官方信息：<strong>64KB</strong>, 4-way set associative, <strong>VIPT behaving as PIPT</strong>, 64B cacheline, ECC protected, RRIP replacement policy, <strong>4×64-bit read paths</strong> and <strong>4×64-bit write</strong> paths for the integer execute pipeline, <strong>3×128-bit read paths</strong> and <strong>2×128-bit</strong> write paths for the vector execute pipeline</p>\n<p>无论官方信息还是下面的实测结果，都和 Neoverse V2 相同。</p>\n<h4 id=\"容量\">容量</h4>\n<p>构造不同大小 footprint 的 pointer chasing 链，测试每条 load 指令的耗时：</p>\n<p><img alt=\"\" src=\"../../../../arm-neoverse-v3-l1dc-size.png\" /></p>\n<p>64KB 处出现拐点，对应 L1 DCache 容量。之后延迟先上升后下降，与 ARM 采用的 Correlated Miss Caching (CMC) 预取器记住了 pointer chasing 的历史有关，详见 <a href=\"https://hc33.hotchips.org/assets/program/conference/day1/20210818_Hotchips_NeoverseN2.pdf\">Arm Neoverse N2: Arm's 2nd generation high performance infrastructure CPUs and system IPs</a>。</p>\n<h4 id=\"延迟\">延迟</h4>\n<p>L1 DCache 的 load to use latency 是 4 cycle，没有针对 pointer chasing 做 3 cycle 优化。</p>\n<h4 id=\"吞吐\">吞吐</h4>\n<p>用 FP/ASIMD 128b Load 可以达到 3 IPC，对应 3x128b read paths；用 2x64b 整数 LDP 只能到 2 IPC，对应 4x64b read paths。要达到峰值读取性能，必须用 FP/ASIMD 指令。向量 128b Store 可以达到 2 IPC，对应 2x128b write paths；2x64b 整数 STP 也能到 2 IPC，对应 4x64b write paths。</p>\n<h4 id=\"vipt\">VIPT</h4>\n<p>4KB page 下，64KB 4-way 的 L1 DCache 不满足 VIPT 的 Index 全在页内偏移的条件（详见 <a href=\"../../../../2023/12/08/vipt-l1-cache-page-size/\">VIPT 与缓存大小和页表大小的关系</a>）。此时要么用 PIPT，要么在 VIPT 基础上处理 alias 问题。参考 <a href=\"https://blog.cyyself.name/why-the-big-l1-cache-is-so-hard/\">浅谈现代处理器实现超大 L1 Cache 的方式</a> 的测试方法，用 shm 构造两个 4KB 虚拟页映射到同一个物理页，然后在两个虚拟页之间 copy，发现相比同一个虚拟页内 copy 有显著的性能下降，并产生了大量 L1 DCache Refill：</p>\n<div class=\"language-text highlight\"><pre><span></span><code><span id=\"__span-0-1\"><a id=\"__codelineno-0-1\" name=\"__codelineno-0-1\" href=\"#__codelineno-0-1\"></a>copy from aliased page = 8778731053 cycles, 55305 refills\n</span><span id=\"__span-0-2\"><a id=\"__codelineno-0-2\" name=\"__codelineno-0-2\" href=\"#__codelineno-0-2\"></a>baseline = 5298206743 cycles, 31413 refills\n</span><span id=\"__span-0-3\"><a id=\"__codelineno-0-3\" name=\"__codelineno-0-3\" href=\"#__codelineno-0-3\"></a>slowdown = 1.66x\n</span></code></pre></div>\n<p>这验证了 L1 DCache 采用的是 VIPT，并在正确性上做了 alias 处理。如果是 PIPT，L1 DCache 会发现两个页对应相同物理地址，性能不会下降，也不需要频繁 refill。</p>\n<h4 id=\"构造\">构造</h4>\n<p>为了支持每周期 3 条 Load，L1 DCache 通常会分 Bank，每个 Bank 有自己的读口。Load 分布到不同 Bank 上时可以同时读取；命中相同 Bank 但访问不同地址，就只能等下个周期。为了测试 Bank 构造，设计了一系列以不同固定 stride 间隔的 Load 指令：</p>\n<ul>\n<li>Stride=1B/2B/4B/8B/16B/32B: IPC=3</li>\n<li>Stride=64B: IPC=2</li>\n<li>Stride=128B/256B/512B: IPC=1</li>\n</ul>\n<p>Stride=64B 时出现 Bank Conflict，Stride=128B 时所有 Load 命中同一个 Bank，只能串行读取。根据这个现象，认为 Neoverse V3 的 L1 DCache 组织方式是：</p>\n<ul>\n<li>一共有两个 Bank，Bank Index 是 VA[6]</li>\n<li>每个 Bank 每周期可以从一个缓存行读取数据</li>\n<li>支持多个 Load 访问同一个缓存行</li>\n<li>多个 Load 访问同一个 Bank 的不同缓存行，只能一个周期完成一个 Load</li>\n</ul>\n<p>这里讨论的是缓存行级别的 Bank。缓存行内部也会做 Bank 划分，但主要是为了功耗，比如从 64B 缓存行读 8B 数据，不需要把整个 64B 都读出来。</p>\n<h3 id=\"l1-dtlb\">L1 DTLB</h3>\n<p>官方信息：Caches entries at the 4KB, 16KB, 64KB, 2MB or 512MB granularity, Fully associative, <strong>96</strong> entries.</p>\n<p>用 pointer chasing 测试 L1 DTLB 容量，指针分布在不同的 page 上，让 DTLB 成为瓶颈：</p>\n<p><img alt=\"\" src=\"../../../../arm-neoverse-v3-l1dtlb-size.png\" /></p>\n<p>96 Page 处出现拐点，对应 96 项的 L1 DTLB 容量。超出后需要额外 6 cycle 访问 L2 Unified TLB。容量相比 Neoverse V2 翻番。测试时注意避免 Huge Page 的影响。</p>\n<h3 id=\"l2-unified-tlb\">L2 Unified TLB</h3>\n<p>官方信息：Shared by instructions and data, 8-way set associative, 2048 entries</p>\n<h3 id=\"l2-cache\">L2 Cache</h3>\n<p>官方信息：2MB or 3MB, 8-way(2MB) or 12-way(3MB) set associative, 4 banks, PIPT, ECC protected, 64B cacheline</p>\n<h3 id=\"sve\">SVE</h3>\n<p>官方信息：128b SVE vector length</p>\n<p>Linux 下查看 <code>/proc/sys/abi/sve_default_vector_length</code>，SVE 宽度为 16 字节，即 128b。</p>\n<p>Neoverse V3 每周期最多执行 4 条 ASIMD 或 SVE 浮点 FMA 指令，浮点峰值性能：</p>\n<ul>\n<li>单精度：<code>128/32*2*4=32</code> FLOP per cycle</li>\n<li>双精度：<code>128/64*2*4=16</code> FLOP per cycle</li>\n</ul>\n<p>与 Neoverse V2、Zen 2-4、Oryon、Firestorm、LA464、Haswell 等微架构看齐，但不及 Zen 5、Skylake 等通过 AVX512 提供的峰值浮点性能。</p>\n<h2 id=\"总结\">总结</h2>\n<p>Neoverse V3 相比 Neoverse V2 改动不算很大，主要变化：</p>\n<ul>\n<li>Decode 宽度从 6(8)-wide 增加到 10-wide，但去掉了 MOP Cache</li>\n<li>ROB 从 320 MOP 增加到 384 MOP</li>\n<li>LSU 从 2 LS + 1 LD 改为 1 LS + 2 LD + 1 ST</li>\n<li>L1 DTLB 从 48 项翻倍到 96 项</li>\n<li>Memory Dependency Predictor 从 40 增加到 56</li>\n</ul>\n<p>整体上是一次稳健的迭代升级。</p>","date_modified":"2026-06-13T00:00:00+00:00","date_published":"2026-06-13T00:00:00+00:00","id":"https://jia.je/hardware/2026/06/13/arm-neoverse-v3/","image":null,"tags":["arm","cpu","hardware","neoverse","performance","uarch-review"],"title":"ARM Neoverse V3 (代号 Poseidon) 微架构评测","url":"https://jia.je/hardware/2026/06/13/arm-neoverse-v3/"},{"authors":[],"content_html":"<h1 id=\"spec-cpu-2026-workload-analysis-fp-rate\">SPEC CPU 2026 Workload Analysis (FP Rate)</h1>\n<p><a href=\"../spec-cpu-2026-workload-analysis-fp-rate/\">中文版本</a></p>\n<h2 id=\"background\">Background</h2>\n<p>Following the <a href=\"../../22/spec-cpu-2026-workload-analysis-int-rate-en/\">INT Rate article</a>, this article continues with the workload analysis of SPEC FP 2026 Rate.</p>\n<!-- more -->\n\n<p>The test environment is the same as the previous <a href=\"../../22/spec-cpu-2026-workload-analysis-int-rate-en/\">INT Rate article</a> and won't be repeated here.</p>\n<p>Recommended reading: <a href=\"https://chipsandcheese.com/p/evaluating-spec-cpu2026\">Evaluating SPEC CPU2026</a> and <a href=\"https://arxiv.org/abs/2605.03713v2\">SPEC CPU2026: Characterization, Representativeness, and Cross-Suite Comparison</a></p>\n<h2 id=\"spec-fp-2026-rate-analysis\">SPEC FP 2026 Rate Analysis</h2>\n<h3 id=\"709cactus_r\">709.cactus_r</h3>\n<p>Cactus is a computational framework, used here to solve the Einstein equations in vacuum. Command:</p>\n<div class=\"language-shell highlight\"><pre><span></span><code><span id=\"__span-0-1\"><a id=\"__codelineno-0-1\" name=\"__codelineno-0-1\" href=\"#__codelineno-0-1\"></a>cactus<span class=\"w\"> </span>ShiftedGaugeWave.par\n</span></code></pre></div>\n<p>Measured runtime is 103.4s, reftime is 858s, corresponding to 8.30 points. Performance under different compilers and flags:</p>\n<table>\n<thead>\n<tr>\n<th>Compiler + Flags</th>\n<th>Time (s)</th>\n<th>Score</th>\n<th>Improvement over GCC 14 <code>-O3</code> (%)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>GCC 14 <code>-O3</code></td>\n<td>103.4</td>\n<td>8.30</td>\n<td>0</td>\n</tr>\n<tr>\n<td>GCC 14 <code>-O3 -march=native</code></td>\n<td>83.9</td>\n<td>10.23</td>\n<td>23</td>\n</tr>\n<tr>\n<td>GCC 14 <code>-O3 -ffast-math</code></td>\n<td>101.2</td>\n<td>8.48</td>\n<td>2</td>\n</tr>\n<tr>\n<td>GCC 14 <code>-O3 -ljemalloc</code></td>\n<td>100.7</td>\n<td>8.52</td>\n<td>3</td>\n</tr>\n<tr>\n<td>LLVM 22 <code>-O3</code></td>\n<td>94.6</td>\n<td>9.07</td>\n<td>9</td>\n</tr>\n<tr>\n<td>LLVM 22 <code>-O3 -march=native</code></td>\n<td>90.5</td>\n<td>9.48</td>\n<td>14</td>\n</tr>\n</tbody>\n</table>\n<p><code>-march=native</code> provides a significant performance boost. LLVM 22 is faster than GCC 14 under <code>-O3</code>, but GCC 14's <code>-O3 -march=native</code> overtakes LLVM 22's <code>-O3 -march=native</code>. Details below.</p>\n<p>Performance bottlenecks observed via <code>perf</code>:</p>\n<ul>\n<li><code>ML_CCZ4::ML_CCZ4_EvolutionInteriorSplitBy2_Body</code> from <code>src/repos/mclachlan/ML_CCZ4/src/ML_CCZ4_EvolutionInteriorSplitBy2.cc</code>: 41.30% of total time (same format below);</li>\n<li><code>ML_CCZ4::ML_CCZ4_EvolutionInteriorSplitBy3_Body</code> from <code>src/repos/mclachlan/ML_CCZ4/src/ML_CCZ4_EvolutionInteriorSplitBy3.cc</code>: 31.26%;</li>\n<li><code>ML_CCZ4::ML_CCZ4_ConstraintsInterior_Body</code> from <code>src/repos/mclachlan/ML_CCZ4/src/ML_CCZ4_ConstraintsInterior_Body.cc</code>: 6.71%;</li>\n<li><code>ML_CCZ4::ML_CCZ4_EvolutionInteriorSplitBy1_Body</code> from <code>src/repos/mclachlan/ML_CCZ4/src/ML_CCZ4_EvolutionInteriorSplitBy1.cc</code>: 6.44%.</li>\n</ul>\n<p>These hotspot functions share a similar pattern: within three nested loops, they read data from corresponding 3D grid points, perform a series of Stencil memory accesses and floating-point operations (including heavy use of floating-point multiply, add, subtract, pow, and fabs), then write results back to arrays. The generated instructions use SSE for scalar double-precision floating-point without vectorization. During testing, compiler optimizations on <code>pow</code> and <code>fabs</code> were also observed. Under <code>-O3</code>, <code>pow(a, 1)</code> compiles to <code>a</code>, <code>pow(a, 2)</code> to <code>a * a</code>, and <code>pow(a, -1)</code> to <code>1.0 / a</code>, but others like <code>pow(a, 3)</code> and <code>pow(a, -2)</code> fall back to libm's <code>pow</code> implementation. With <code>-O3 -ffast-math</code>, <code>pow(a, 3)</code> becomes <code>a * a * a</code> and <code>pow(a, -2)</code> becomes <code>1.0 / (a * a)</code>. See the comparison at <a href=\"https://godbolt.org/z/nKfGMfE49\">Godbolt</a>. In the code, the main occurrences are <code>pow(a, -1)</code>, <code>pow(a, 2)</code>, <code>pow(a, -2)</code>, and <code>pow(a, runtimeVariable)</code>, where <code>runtimeVariable</code> is a value only known at runtime, corresponding to <code>shiftAlphaPower</code> or <code>harmonicN</code> in the code. <code>fabs</code> is compiled into the bitwise <code>andpd</code> instruction, directly zeroing the sign bit.</p>\n<p>With <code>-O3 -march=native</code>, vectorization still doesn't happen. It uses AVX2 instructions for scalar double-precision floating-point, with remaining calls to libm's <code>pow</code> for the cases mentioned above (<code>pow(a, -2)</code> or <code>pow(a, runtimeVariable)</code>). However, the rest of the computation benefits from <a href=\"https://www.felixcloutier.com/x86/vfmadd132sd:vfmadd213sd:vfmadd231sd\"><code>vfmadd132sd</code></a>/<code>vfnmadd132sd</code>, and <a href=\"https://www.felixcloutier.com/x86/addsd\"><code>vaddsd</code></a> becomes a three-operand instruction (compared to the two-operand <a href=\"https://www.felixcloutier.com/x86/addsd\"><code>addsd</code></a>) that also allows memory operands, further reducing instruction count. On ARM64, <code>-march=native</code> provides no improvement because the floating-point fused multiply-add instruction is available even without <code>-march=native</code>, see <a href=\"https://godbolt.org/z/nqMjY4EoY\">Godbolt</a>. In a sense, the huge improvement from <code>-march=native</code> on AMD64 reflects a first-mover disadvantage: the baseline corresponds to very old processors lacking many important ISA extensions. This compatibility burden doesn't exist on many other ISAs; for instance, fused multiply-add (FMA) is already part of the baseline in many ISAs, where <code>-march=native</code> brings relatively smaller improvements. As a workaround, many software projects manually provide multiple code paths for different ISA extensions and select the best one at runtime based on availability. If compilers could do this automatically, it would bring nice overall performance improvements while maintaining compatibility and developer convenience.</p>\n<p>Performance counter comparison across compilation options:</p>\n<table>\n<thead>\n<tr>\n<th>Compiler + Flags</th>\n<th>Time (s)</th>\n<th>Insns (B)</th>\n<th>Load (B)</th>\n<th>Store (B)</th>\n<th>Branch (B)</th>\n<th>FP Scalar (B)</th>\n<th>FP Vector (B)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>GCC 14 <code>-O3</code></td>\n<td>103.4</td>\n<td>1423.6</td>\n<td>747.8</td>\n<td>110.1</td>\n<td>9.8</td>\n<td>677.0</td>\n<td>5.2</td>\n</tr>\n<tr>\n<td>GCC 14 <code>-O3 -march=native</code></td>\n<td>83.9</td>\n<td>988.5</td>\n<td>711.9</td>\n<td>89.5</td>\n<td>8.9</td>\n<td>686.1</td>\n<td>2.6</td>\n</tr>\n<tr>\n<td>GCC 14 <code>-O3 -ffast-math</code></td>\n<td>101.8</td>\n<td>1387.7</td>\n<td>742.2</td>\n<td>103.4</td>\n<td>5.3</td>\n<td>641.0</td>\n<td>5.6</td>\n</tr>\n<tr>\n<td>GCC 14 <code>-O3 -ljemalloc</code></td>\n<td>100.7</td>\n<td>1423.6</td>\n<td>747.8</td>\n<td>110.1</td>\n<td>9.8</td>\n<td>677.0</td>\n<td>5.2</td>\n</tr>\n<tr>\n<td>LLVM 22 <code>-O3</code></td>\n<td>94.6</td>\n<td>1323.1</td>\n<td>659.1</td>\n<td>96.6</td>\n<td>6.1</td>\n<td>659.0</td>\n<td>15.2</td>\n</tr>\n<tr>\n<td>LLVM 22 <code>-O3 -march=native</code></td>\n<td>90.5</td>\n<td>1054.5</td>\n<td>690.7</td>\n<td>119.4</td>\n<td>5.4</td>\n<td>681.4</td>\n<td>5.4</td>\n</tr>\n</tbody>\n</table>\n<p>Total instruction count comes from <code>instructions</code>, Load from <code>mem_inst_retired.all_loads</code>, Store from <code>mem_inst_retired.all_stores</code>, Branch from <code>branch-instructions</code>, FP Scalar from <code>fp_arith_inst_retired.scalar</code>, and FP Vector from <code>fp_arith_inst_retired.vector</code> performance counters (same format below). Note that fused multiply-add instructions like <code>vfmadd132sd</code> are counted twice in <code>fp_arith_inst_retired.scalar/vector</code>.</p>\n<p>From the table, under <code>-O3</code> roughly half the instructions are Loads and the other half are floating-point scalar operations. This low compute-to-memory ratio is typical of Stencil computation: load a value from the grid neighborhood, do one multiply-add. With <code>-O3 -march=native</code>, FMA instructions reduce the instruction count substantially, but since FMA counts double and AVX2 instructions that perform both memory access and computation are counted in both Load and FP categories (the microarchitecture likely counts split micro-ops), the total instruction count no longer equals the sum of individual categories. The <code>-O3 -ljemalloc</code> option provides a slight performance advantage not reflected in instruction counts; its improvement mainly comes from better cache locality. GCC 14 and LLVM 22 have comparable performance under different flags. The generated instructions are similar in approach, with main differences in address computation, stack usage, and register allocation.</p>\n<p>Notably, 709.cactus_r has high cache miss rates: under GCC 14 <code>-O3</code>, L1 ICache MPKI reaches <code>118.6B/1423.6B*1000=83.30</code>, and L1 DCache MPKI is <code>125.6B/1423.6B*1000=88.23</code>, the highest among both SPEC FP 2026 Rate and SPEC INT 2026 Rate. Cores with larger L1 ICache have an advantage here; L1 ICache bottlenecks at 32KB might disappear at 64KB. With <code>-O3 -ljemalloc</code>, L1 DCache MPKI drops to <code>111.7B/1423.6B*1000=78.46</code>, yielding about 3% improvement with identical instruction counts compared to <code>-O3</code>.</p>\n<h3 id=\"722palm_r\">722.palm_r</h3>\n<p>palm is a weather forecasting program that solves Navier-Stokes equations. Command:</p>\n<div class=\"language-shell highlight\"><pre><span></span><code><span id=\"__span-1-1\"><a id=\"__codelineno-1-1\" name=\"__codelineno-1-1\" href=\"#__codelineno-1-1\"></a>palm_r<span class=\"w\"> </span>&lt;<span class=\"w\"> </span>runfile_atmos\n</span></code></pre></div>\n<p>Measured runtime is 174.0s, reftime is 1320s, corresponding to 7.59 points. Performance under different compilers and flags:</p>\n<table>\n<thead>\n<tr>\n<th>Compiler + Flags</th>\n<th>Time (s)</th>\n<th>Score</th>\n<th>Improvement over GCC 14 <code>-O3</code> (%)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>GCC 14 <code>-O3</code></td>\n<td>174.0</td>\n<td>7.59</td>\n<td>0</td>\n</tr>\n<tr>\n<td>GCC 14 <code>-O3 -march=native</code></td>\n<td>157.8</td>\n<td>8.34</td>\n<td>10</td>\n</tr>\n<tr>\n<td>GCC 14 <code>-O3 -ffast-math</code></td>\n<td>168.4</td>\n<td>7.84</td>\n<td>3</td>\n</tr>\n<tr>\n<td>GCC 14 <code>-O3 -ljemalloc</code></td>\n<td>172.4</td>\n<td>7.66</td>\n<td>1</td>\n</tr>\n<tr>\n<td>LLVM 22 <code>-O3</code></td>\n<td>144.0</td>\n<td>9.17</td>\n<td>21</td>\n</tr>\n<tr>\n<td>LLVM 22 <code>-O3 -march=native</code></td>\n<td>118.6</td>\n<td>11.13</td>\n<td>47</td>\n</tr>\n</tbody>\n</table>\n<p>The trend is similar to 709.cactus_r: <code>-O3 -march=native</code> provides a massive performance boost, and LLVM 22 is significantly faster than GCC 14.</p>\n<p>Hotspot functions:</p>\n<ul>\n<li><code>advec_s_ws_ij</code> from <code>src/advec_ws.F90</code>: 9.80%, classic 3D Stencil computation with balanced memory access and computation ratio, essentially load one point value then do multiply-add. Uses SSE for computation with partial vectorization (addpd/subpd/mulpd processing 2 double-precision elements per instruction), though some loops fail to vectorize and fall back to scalar instructions (addsd/subsd/mulsd);</li>\n<li><code>advec_u_ws_ij</code> from <code>src/advec_ws.F90</code>: 8.80%, same as above;</li>\n<li><code>advec_v_ws_ij</code> from <code>src/advec_ws.F90</code>: 8.54%, same as above;</li>\n<li><code>advec_w_ws_ij</code> from <code>src/advec_ws.F90</code>: 8.24%, same as above;</li>\n<li><code>diffusion_e_ij</code> from <code>src/turbulence_closure_mod.F90</code>: 5.14%, involves more complex floating-point operations like min/sqrt/div, plus bitwise operations using <code>MERGE</code> for ternary operations, no vectorization, scalar SSE floating-point.</li>\n</ul>\n<p>Here is the Stencil computation code from <code>advec_s_ws_ij</code>, looping over i, j, k:</p>\n<div class=\"language-fortran highlight\"><pre><span></span><code><span id=\"__span-2-1\"><a id=\"__codelineno-2-1\" name=\"__codelineno-2-1\" href=\"#__codelineno-2-1\"></a><span class=\"n\">flux_r</span><span class=\"p\">(</span><span class=\"n\">k</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span><span class=\"n\">u_comp</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"w\">                                                                </span><span class=\"p\">&amp;</span>\n</span><span id=\"__span-2-2\"><a id=\"__codelineno-2-2\" name=\"__codelineno-2-2\" href=\"#__codelineno-2-2\"></a><span class=\"w\">              </span><span class=\"mi\">3</span><span class=\"mf\">7.0_wp</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"w\"> </span><span class=\"n\">sk</span><span class=\"p\">(</span><span class=\"n\">k</span><span class=\"p\">,</span><span class=\"n\">j</span><span class=\"p\">,</span><span class=\"n\">i</span><span class=\"o\">+</span><span class=\"mi\">1</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"n\">sk</span><span class=\"p\">(</span><span class=\"n\">k</span><span class=\"p\">,</span><span class=\"n\">j</span><span class=\"p\">,</span><span class=\"n\">i</span><span class=\"p\">)</span><span class=\"w\">   </span><span class=\"p\">)</span><span class=\"w\">                                 </span><span class=\"p\">&amp;</span>\n</span><span id=\"__span-2-3\"><a id=\"__codelineno-2-3\" name=\"__codelineno-2-3\" href=\"#__codelineno-2-3\"></a><span class=\"w\">            </span><span class=\"o\">-</span><span class=\"w\">  </span><span class=\"mf\">8.0_wp</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"w\"> </span><span class=\"n\">sk</span><span class=\"p\">(</span><span class=\"n\">k</span><span class=\"p\">,</span><span class=\"n\">j</span><span class=\"p\">,</span><span class=\"n\">i</span><span class=\"o\">+</span><span class=\"mi\">2</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"n\">sk</span><span class=\"p\">(</span><span class=\"n\">k</span><span class=\"p\">,</span><span class=\"n\">j</span><span class=\"p\">,</span><span class=\"n\">i</span><span class=\"o\">-</span><span class=\"mi\">1</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"p\">)</span><span class=\"w\">                                 </span><span class=\"p\">&amp;</span>\n</span><span id=\"__span-2-4\"><a id=\"__codelineno-2-4\" name=\"__codelineno-2-4\" href=\"#__codelineno-2-4\"></a><span class=\"w\">            </span><span class=\"o\">+</span><span class=\"w\">           </span><span class=\"p\">(</span><span class=\"w\"> </span><span class=\"n\">sk</span><span class=\"p\">(</span><span class=\"n\">k</span><span class=\"p\">,</span><span class=\"n\">j</span><span class=\"p\">,</span><span class=\"n\">i</span><span class=\"o\">+</span><span class=\"mi\">3</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"n\">sk</span><span class=\"p\">(</span><span class=\"n\">k</span><span class=\"p\">,</span><span class=\"n\">j</span><span class=\"p\">,</span><span class=\"n\">i</span><span class=\"o\">-</span><span class=\"mi\">2</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">adv_sca_5</span>\n</span></code></pre></div>\n<p>Performance counter comparison:</p>\n<table>\n<thead>\n<tr>\n<th>Compiler + Flags</th>\n<th>Time (s)</th>\n<th>Insns (B)</th>\n<th>Load (B)</th>\n<th>Store (B)</th>\n<th>Branch (B)</th>\n<th>FP Scalar (B)</th>\n<th>FP Vector (B)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>GCC 14 <code>-O3</code></td>\n<td>174.0</td>\n<td>3416.6</td>\n<td>1267.4</td>\n<td>271.1</td>\n<td>155.6</td>\n<td>779.0</td>\n<td>318.5</td>\n</tr>\n<tr>\n<td>GCC 14 <code>-O3 -march=native</code></td>\n<td>157.8</td>\n<td>2710.0</td>\n<td>1212.8</td>\n<td>242.5</td>\n<td>147.1</td>\n<td>785.9</td>\n<td>172.6</td>\n</tr>\n<tr>\n<td>GCC 14 <code>-O3 -ffast-math</code></td>\n<td>168.4</td>\n<td>3373.5</td>\n<td>1204.7</td>\n<td>278.0</td>\n<td>134.0</td>\n<td>612.8</td>\n<td>363.1</td>\n</tr>\n<tr>\n<td>GCC 14 <code>-O3 -ljemalloc</code></td>\n<td>172.4</td>\n<td>3368.4</td>\n<td>1259.7</td>\n<td>260.7</td>\n<td>141.6</td>\n<td>779.0</td>\n<td>318.5</td>\n</tr>\n<tr>\n<td>LLVM 22 <code>-O3</code></td>\n<td>144.0</td>\n<td>2640.4</td>\n<td>835.5</td>\n<td>216.3</td>\n<td>90.4</td>\n<td>179.5</td>\n<td>609.7</td>\n</tr>\n<tr>\n<td>LLVM 22 <code>-O3 -march=native</code></td>\n<td>118.6</td>\n<td>1643.8</td>\n<td>586.5</td>\n<td>165.6</td>\n<td>67.6</td>\n<td>180.8</td>\n<td>306.7</td>\n</tr>\n</tbody>\n</table>\n<p>With <code>-O3 -march=native</code>, heavy AVX2 vectorized instructions appear: vmulpd/vdivsd/vaddpd/vsubpd/vfmadd213sd/vfmsub132pd/vfmsub231pd/vmovupd, each processing 4 double-precision elements. Vectorization degree is high; on AVX512-capable processors, performance could be even higher. Compared to 709.cactus_r where pow and similar issues prevent vectorization, 722.palm_r's vectorization benefits are much more apparent. LLVM 22 under <code>-O3</code> outperforms GCC 14 because it successfully vectorizes hotspot functions like <code>advec_u/v/w_ws_ij</code>, while GCC 14 still uses scalar instructions. This is reflected in significantly more FP vector instructions and fewer FP scalar instructions. Under LLVM 22, with those hotspot functions well-optimized, <code>flow_statistics</code> (from <code>src/flow_statistics.F90</code>, 5.79% time share) becomes the new bottleneck. It has limited vectorizable portions, hence its time share increases. Even with <code>-O3 -march=native</code>, it still uses AVX2+FMA instructions for scalar computation with little time difference. As other parts speed up, its time share further increases to 6.95%, similar to Amdahl's law.</p>\n<p>709.cactus_r and 722.palm_r share the same Stencil computation pattern. Physics simulations frequently do this: solving differential equations in 3D space requires repeated computation over each point's neighborhood, which ultimately becomes Stencil.</p>\n<h3 id=\"731astcenc_r\">731.astcenc_r</h3>\n<p>astcenc is an encoder for the ASTC lossy compressed image format. It runs three times:</p>\n<div class=\"language-shell highlight\"><pre><span></span><code><span id=\"__span-3-1\"><a id=\"__codelineno-3-1\" name=\"__codelineno-3-1\" href=\"#__codelineno-3-1\"></a><span class=\"c1\"># 1. linear</span>\n</span><span id=\"__span-3-2\"><a id=\"__codelineno-3-2\" name=\"__codelineno-3-2\" href=\"#__codelineno-3-2\"></a>astcenc_r<span class=\"w\"> </span>ref-inputs-linear.txt\n</span><span id=\"__span-3-3\"><a id=\"__codelineno-3-3\" name=\"__codelineno-3-3\" href=\"#__codelineno-3-3\"></a><span class=\"c1\"># 2. hdr</span>\n</span><span id=\"__span-3-4\"><a id=\"__codelineno-3-4\" name=\"__codelineno-3-4\" href=\"#__codelineno-3-4\"></a>astcenc_r<span class=\"w\"> </span>ref-inputs-hdr.txt\n</span><span id=\"__span-3-5\"><a id=\"__codelineno-3-5\" name=\"__codelineno-3-5\" href=\"#__codelineno-3-5\"></a><span class=\"c1\"># 3. precision</span>\n</span><span id=\"__span-3-6\"><a id=\"__codelineno-3-6\" name=\"__codelineno-3-6\" href=\"#__codelineno-3-6\"></a>astcenc_r<span class=\"w\"> </span>ref-inputs-precision.txt\n</span></code></pre></div>\n<p>Measured runtimes are 49.9s, 72.1s, and 53.8s, totaling 175.8s, reftime 840s, corresponding to 4.78 points. Performance under different compilers and flags:</p>\n<table>\n<thead>\n<tr>\n<th>Compiler + Flags</th>\n<th>Total Time (s)</th>\n<th>1. linear (s)</th>\n<th>2. hdr (s)</th>\n<th>3. precision (s)</th>\n<th>Score</th>\n<th>Improvement over GCC 14 <code>-O3</code> (%)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>GCC 14 <code>-O3</code></td>\n<td>175.8</td>\n<td>49.9</td>\n<td>72.1</td>\n<td>53.8</td>\n<td>4.78</td>\n<td>0</td>\n</tr>\n<tr>\n<td>GCC 14 <code>-O3 -march=native</code></td>\n<td>157.3</td>\n<td>44.0</td>\n<td>63.2</td>\n<td>50.0</td>\n<td>5.34</td>\n<td>12</td>\n</tr>\n<tr>\n<td>GCC 14 <code>-O3 -ffast-math</code></td>\n<td>160.5</td>\n<td>44.6</td>\n<td>67.2</td>\n<td>48.7</td>\n<td>5.23</td>\n<td>10</td>\n</tr>\n<tr>\n<td>LLVM 22 <code>-O3</code></td>\n<td>134.0</td>\n<td>38.5</td>\n<td>56.1</td>\n<td>39.3</td>\n<td>6.27</td>\n<td>31</td>\n</tr>\n<tr>\n<td>LLVM 22 <code>-O3 -march=native</code></td>\n<td>117.2</td>\n<td>34.4</td>\n<td>48.6</td>\n<td>34.1</td>\n<td>7.17</td>\n<td>50</td>\n</tr>\n</tbody>\n</table>\n<p>Another benchmark where LLVM 22 has a clear advantage over GCC 14. Other flags like <code>-flto</code> and <code>-ljemalloc</code> have almost no impact and are omitted. 731.astcenc_r has the highest MPKI in SPEC FP 2026 Rate at 5.0, much higher than most others which are below 1.0 (second highest is 737.gmsh_r at 3.33, third is 767.nest_r at only 0.83), and also higher than many SPEC INT 2026 Rate benchmarks. Below is per-workload analysis.</p>\n<h4 id=\"1-linear\">1. linear</h4>\n<p>Main hotspot functions:</p>\n<ul>\n<li><code>compute_angular_endpoints_for_quant_levels</code> from <code>src/astcenc_weight_align.cpp</code>: 18.93%, main bottleneck is in the inner loop doing single-precision floating-point scalar SSE computation, with calls to <code>nearbyint</code> from libm for rounding. The developers intentionally wrote SIMD-friendly code using <code>vfloat4</code> for batch operations, with <code>vmask4</code> storing comparison results (four ints, 0 for false, -1 for true), and a <code>select</code> function for vectorized ternary operations. Unfortunately the compiler doesn't cooperate, producing scalar SSE instead;</li>\n<li><code>compute_avgs_and_dirs_3_comp_rgb</code> from <code>src/astcenc_averages_and_directions.cpp</code>: 14.70%, similar pattern with <code>vfloat4</code> and <code>vmask4</code> computations in loops, but SSE instructions are all scalar;</li>\n<li><code>compute_quantized_weights_for_decimation</code> from <code>src/astcenc_ideal_endpoints_and_weights.cpp</code>: 13.34%, involves quantization with <code>vint</code> and table lookups (<code>vtable_lookup_32bit</code>). The <code>vfloat</code>/<code>vint</code> types are designed to automatically map to the platform's available SIMD width (defined in <code>src/astcenc_vecmathlib.h</code>, e.g., AVX maps to 8 elements with vfloat8, SSE to 4 elements with vfloat4), but these wider modes are disabled in SPEC, falling back to 4 elements;</li>\n<li><code>compute_ideal_weights_for_decimation</code> from <code>src/astcenc_ideal_endpoints_and_weights.cpp</code>: 9.57%, main bottleneck is a gather operation <code>gatherf_byte_inds</code>. Since SSE doesn't support gather, it splits into four elements with individual loads and scalar computation;</li>\n<li><code>bilinear_infill_vla</code> from <code>src/astcenc_ideal_endpoints_and_weights.cpp</code>: 7.80%, bottleneck is also the gather operation <code>gatherf_byte_inds</code>;</li>\n<li><code>compute_error_squared_rgb</code> from <code>src/astcenc_averages_and_directions.cpp</code>: 6.39%, bottleneck is gather plus subsequent vector computation, but GCC 14 compiles everything to scalar SSE.</li>\n</ul>\n<p>The fact that native SIMD code compiles to scalar instructions also suggests that correct vectorization would yield significant additional performance. Furthermore, with <code>-O3 -march=native</code>, vectors widen to 256 bits, and the <a href=\"https://www.felixcloutier.com/x86/blendvps\"><code>vblendvps</code></a> instruction becomes available to implement the <code>select</code> function. As mentioned, LLVM 22 is significantly faster. Here's the comparison:</p>\n<table>\n<thead>\n<tr>\n<th>Compiler + Flags</th>\n<th>Time (s)</th>\n<th>Insns (B)</th>\n<th>Load (B)</th>\n<th>Store (B)</th>\n<th>Branch (B)</th>\n<th>FP Scalar (B)</th>\n<th>FP Vector (B)</th>\n<th>Mispred (M)</th>\n<th>MPKI</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>GCC 14 <code>-O3</code></td>\n<td>49.9</td>\n<td>835.7</td>\n<td>259.3</td>\n<td>55.6</td>\n<td>63.2</td>\n<td>188.6</td>\n<td>28.6</td>\n<td>3136.0</td>\n<td>3.75</td>\n</tr>\n<tr>\n<td>GCC 14 <code>-O3 -march=native</code></td>\n<td>44.0</td>\n<td>652.4</td>\n<td>234.0</td>\n<td>46.3</td>\n<td>52.9</td>\n<td>184.6</td>\n<td>28.5</td>\n<td>3148.2</td>\n<td>4.83</td>\n</tr>\n<tr>\n<td>GCC 14 <code>-O3 -ffast-math</code></td>\n<td>44.6</td>\n<td>780.5</td>\n<td>259.8</td>\n<td>54.6</td>\n<td>49.3</td>\n<td>159.9</td>\n<td>43.2</td>\n<td>2139.0</td>\n<td>2.74</td>\n</tr>\n<tr>\n<td>LLVM 22 <code>-O3</code></td>\n<td>38.5</td>\n<td>829.7</td>\n<td>235.0</td>\n<td>34.8</td>\n<td>36.1</td>\n<td>68.8</td>\n<td>155.6</td>\n<td>1095.5</td>\n<td>1.32</td>\n</tr>\n<tr>\n<td>LLVM 22 <code>-O3 -march=native</code></td>\n<td>34.4</td>\n<td>620.9</td>\n<td>179.5</td>\n<td>17.7</td>\n<td>19.6</td>\n<td>42.1</td>\n<td>125.7</td>\n<td>823.4</td>\n<td>1.33</td>\n</tr>\n</tbody>\n</table>\n<p>The counters show GCC 14 performs worse overall because LLVM 22 does more vectorization: its FP vector instructions far exceed FP scalar, with significantly fewer mispredictions and much lower MPKI. Detailed analysis follows.</p>\n<p>First, let's look at how GCC 14 compiles 731.astcenc_r's SIMD-native code. Taking the hotspot functions analyzed above as examples, a common pattern uses <code>vfloat4</code> comparison plus <code>select</code> to implement vectorized max:</p>\n<div class=\"language-cpp highlight\"><pre><span></span><code><span id=\"__span-4-1\"><a id=\"__codelineno-4-1\" name=\"__codelineno-4-1\" href=\"#__codelineno-4-1\"></a><span class=\"n\">vfloat4</span><span class=\"w\"> </span><span class=\"nf\">vmax</span><span class=\"p\">(</span><span class=\"n\">vfloat4</span><span class=\"w\"> </span><span class=\"n\">a</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"n\">vfloat4</span><span class=\"w\"> </span><span class=\"n\">b</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"p\">{</span>\n</span><span id=\"__span-4-2\"><a id=\"__codelineno-4-2\" name=\"__codelineno-4-2\" href=\"#__codelineno-4-2\"></a><span class=\"w\">  </span><span class=\"n\">vmask4</span><span class=\"w\"> </span><span class=\"n\">mask</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span><span class=\"n\">b</span><span class=\"w\"> </span><span class=\"o\">&gt;</span><span class=\"w\"> </span><span class=\"n\">a</span><span class=\"p\">;</span>\n</span><span id=\"__span-4-3\"><a id=\"__codelineno-4-3\" name=\"__codelineno-4-3\" href=\"#__codelineno-4-3\"></a><span class=\"w\">  </span><span class=\"k\">return</span><span class=\"w\"> </span><span class=\"n\">select</span><span class=\"p\">(</span><span class=\"n\">a</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"n\">b</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"n\">mask</span><span class=\"p\">);</span>\n</span><span id=\"__span-4-4\"><a id=\"__codelineno-4-4\" name=\"__codelineno-4-4\" href=\"#__codelineno-4-4\"></a><span class=\"p\">}</span>\n</span></code></pre></div>\n<p>Under <code>-O3</code>, GCC 14 compiles this to:</p>\n<div class=\"language-asm highlight\"><pre><span></span><code><span id=\"__span-5-1\"><a id=\"__codelineno-5-1\" name=\"__codelineno-5-1\" href=\"#__codelineno-5-1\"></a><span class=\"nf\">vmax</span><span class=\"p\">(</span><span class=\"no\">vfloat4</span><span class=\"w\"> </span><span class=\"no\">a</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"no\">vfloat4</span><span class=\"w\"> </span><span class=\"no\">b</span><span class=\"p\">):</span>\n</span><span id=\"__span-5-2\"><a id=\"__codelineno-5-2\" name=\"__codelineno-5-2\" href=\"#__codelineno-5-2\"></a><span class=\"w\">        </span><span class=\"c1\"># a vector in xmm0 (a[0] and a[1]) and xmm1 (a[2] and a[3]) registers</span>\n</span><span id=\"__span-5-3\"><a id=\"__codelineno-5-3\" name=\"__codelineno-5-3\" href=\"#__codelineno-5-3\"></a><span class=\"w\">        </span><span class=\"c1\"># b vector in xmm2 (b[0] and b[1]) and xmm3 (b[2] and b[3]) registers</span>\n</span><span id=\"__span-5-4\"><a id=\"__codelineno-5-4\" name=\"__codelineno-5-4\" href=\"#__codelineno-5-4\"></a><span class=\"w\">        </span><span class=\"c1\"># although each element is single-precision, each xmm register only holds two elements</span>\n</span><span id=\"__span-5-5\"><a id=\"__codelineno-5-5\" name=\"__codelineno-5-5\" href=\"#__codelineno-5-5\"></a><span class=\"w\">        </span><span class=\"nf\">movq</span><span class=\"w\">    </span><span class=\"nv\">%xmm1</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%rax</span><span class=\"w\">       </span><span class=\"c1\"># rax = a3 | a2</span>\n</span><span id=\"__span-5-6\"><a id=\"__codelineno-5-6\" name=\"__codelineno-5-6\" href=\"#__codelineno-5-6\"></a><span class=\"w\">        </span><span class=\"nf\">movq</span><span class=\"w\">    </span><span class=\"nv\">%xmm3</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%rcx</span><span class=\"w\">       </span><span class=\"c1\"># rcx = b3 | b2</span>\n</span><span id=\"__span-5-7\"><a id=\"__codelineno-5-7\" name=\"__codelineno-5-7\" href=\"#__codelineno-5-7\"></a><span class=\"w\">        </span><span class=\"nf\">movq</span><span class=\"w\">    </span><span class=\"nv\">%xmm0</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%rsi</span><span class=\"w\">       </span><span class=\"c1\"># rsi = a1 | a0</span>\n</span><span id=\"__span-5-8\"><a id=\"__codelineno-5-8\" name=\"__codelineno-5-8\" href=\"#__codelineno-5-8\"></a><span class=\"w\">        </span><span class=\"nf\">movd</span><span class=\"w\">    </span><span class=\"nv\">%ecx</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%xmm1</span><span class=\"w\">       </span><span class=\"c1\"># xmm1 = b2</span>\n</span><span id=\"__span-5-9\"><a id=\"__codelineno-5-9\" name=\"__codelineno-5-9\" href=\"#__codelineno-5-9\"></a><span class=\"w\">        </span><span class=\"nf\">movd</span><span class=\"w\">    </span><span class=\"nv\">%eax</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%xmm6</span><span class=\"w\">       </span><span class=\"c1\"># xmm6 = a2</span>\n</span><span id=\"__span-5-10\"><a id=\"__codelineno-5-10\" name=\"__codelineno-5-10\" href=\"#__codelineno-5-10\"></a><span class=\"w\">        </span><span class=\"nf\">shrq</span><span class=\"w\">    </span><span class=\"no\">$32</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%rcx</span><span class=\"w\">         </span><span class=\"c1\"># rcx = b3</span>\n</span><span id=\"__span-5-11\"><a id=\"__codelineno-5-11\" name=\"__codelineno-5-11\" href=\"#__codelineno-5-11\"></a><span class=\"w\">        </span><span class=\"nf\">movdqa</span><span class=\"w\">  </span><span class=\"nv\">%xmm2</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%xmm5</span><span class=\"w\">      </span><span class=\"c1\"># xmm5 = b1 | b0</span>\n</span><span id=\"__span-5-12\"><a id=\"__codelineno-5-12\" name=\"__codelineno-5-12\" href=\"#__codelineno-5-12\"></a><span class=\"w\">        </span><span class=\"nf\">shrq</span><span class=\"w\">    </span><span class=\"no\">$32</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%rax</span><span class=\"w\">         </span><span class=\"c1\"># rax = a3</span>\n</span><span id=\"__span-5-13\"><a id=\"__codelineno-5-13\" name=\"__codelineno-5-13\" href=\"#__codelineno-5-13\"></a><span class=\"w\">        </span><span class=\"nf\">movdqa</span><span class=\"w\">  </span><span class=\"nv\">%xmm2</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%xmm0</span><span class=\"w\">      </span><span class=\"c1\"># xmm0 = b1 | b0</span>\n</span><span id=\"__span-5-14\"><a id=\"__codelineno-5-14\" name=\"__codelineno-5-14\" href=\"#__codelineno-5-14\"></a><span class=\"w\">        </span><span class=\"nf\">movd</span><span class=\"w\">    </span><span class=\"nv\">%ecx</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%xmm4</span><span class=\"w\">       </span><span class=\"c1\"># xmm4 = b3</span>\n</span><span id=\"__span-5-15\"><a id=\"__codelineno-5-15\" name=\"__codelineno-5-15\" href=\"#__codelineno-5-15\"></a><span class=\"w\">        </span><span class=\"nf\">shufps</span><span class=\"w\">  </span><span class=\"no\">$85</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%xmm5</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%xmm5</span><span class=\"w\"> </span><span class=\"c1\"># xmm5 = b1 | b1 | b1 | b1</span>\n</span><span id=\"__span-5-16\"><a id=\"__codelineno-5-16\" name=\"__codelineno-5-16\" href=\"#__codelineno-5-16\"></a><span class=\"w\">        </span><span class=\"nf\">movd</span><span class=\"w\">    </span><span class=\"nv\">%eax</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%xmm2</span><span class=\"w\">       </span><span class=\"c1\"># xmm2 = a3</span>\n</span><span id=\"__span-5-17\"><a id=\"__codelineno-5-17\" name=\"__codelineno-5-17\" href=\"#__codelineno-5-17\"></a><span class=\"w\">        </span><span class=\"nf\">movd</span><span class=\"w\">    </span><span class=\"nv\">%esi</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%xmm7</span><span class=\"w\">       </span><span class=\"c1\"># xmm7 = a0</span>\n</span><span id=\"__span-5-18\"><a id=\"__codelineno-5-18\" name=\"__codelineno-5-18\" href=\"#__codelineno-5-18\"></a><span class=\"w\">        </span><span class=\"nf\">shrq</span><span class=\"w\">    </span><span class=\"no\">$32</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%rsi</span><span class=\"w\">         </span><span class=\"c1\"># rsi = a1</span>\n</span><span id=\"__span-5-19\"><a id=\"__codelineno-5-19\" name=\"__codelineno-5-19\" href=\"#__codelineno-5-19\"></a><span class=\"w\">        </span><span class=\"nf\">movdqa</span><span class=\"w\">  </span><span class=\"nv\">%xmm5</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%xmm3</span><span class=\"w\">      </span><span class=\"c1\"># xmm3 = b1 | b1 | b1 | b1</span>\n</span><span id=\"__span-5-20\"><a id=\"__codelineno-5-20\" name=\"__codelineno-5-20\" href=\"#__codelineno-5-20\"></a><span class=\"w\">        </span><span class=\"nf\">comiss</span><span class=\"w\">  </span><span class=\"nv\">%xmm2</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%xmm4</span><span class=\"w\">      </span><span class=\"c1\"># compare a3 and b3</span>\n</span><span id=\"__span-5-21\"><a id=\"__codelineno-5-21\" name=\"__codelineno-5-21\" href=\"#__codelineno-5-21\"></a><span class=\"w\">        </span><span class=\"nf\">movd</span><span class=\"w\">    </span><span class=\"nv\">%esi</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%xmm5</span><span class=\"w\">       </span><span class=\"c1\"># xmm5 = a1</span>\n</span><span id=\"__span-5-22\"><a id=\"__codelineno-5-22\" name=\"__codelineno-5-22\" href=\"#__codelineno-5-22\"></a><span class=\"w\">        </span><span class=\"nf\">seta</span><span class=\"w\">    </span><span class=\"nv\">%al</span><span class=\"w\">               </span><span class=\"c1\"># al = (b3 &gt; a3)</span>\n</span><span id=\"__span-5-23\"><a id=\"__codelineno-5-23\" name=\"__codelineno-5-23\" href=\"#__codelineno-5-23\"></a><span class=\"w\">        </span><span class=\"nf\">comiss</span><span class=\"w\">  </span><span class=\"nv\">%xmm6</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%xmm1</span><span class=\"w\">      </span><span class=\"c1\"># compare b2 and a2</span>\n</span><span id=\"__span-5-24\"><a id=\"__codelineno-5-24\" name=\"__codelineno-5-24\" href=\"#__codelineno-5-24\"></a><span class=\"w\">        </span><span class=\"nf\">jbe</span><span class=\"w\">     </span><span class=\"no\">.L14</span><span class=\"w\">              </span><span class=\"c1\"># if a2 &gt;= b2, jump to .L14</span>\n</span><span id=\"__span-5-25\"><a id=\"__codelineno-5-25\" name=\"__codelineno-5-25\" href=\"#__codelineno-5-25\"></a><span class=\"w\">        </span><span class=\"nf\">testb</span><span class=\"w\">   </span><span class=\"nv\">%al</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%al</span>\n</span><span id=\"__span-5-26\"><a id=\"__codelineno-5-26\" name=\"__codelineno-5-26\" href=\"#__codelineno-5-26\"></a><span class=\"w\">        </span><span class=\"nf\">jne</span><span class=\"w\">     </span><span class=\"no\">.L15</span><span class=\"w\">              </span><span class=\"c1\"># if b3 &gt; a3, jump to .L15</span>\n</span><span id=\"__span-5-27\"><a id=\"__codelineno-5-27\" name=\"__codelineno-5-27\" href=\"#__codelineno-5-27\"></a><span class=\"w\">        </span><span class=\"c1\"># here a2 &lt; b2, a3 &gt;= b3</span>\n</span><span id=\"__span-5-28\"><a id=\"__codelineno-5-28\" name=\"__codelineno-5-28\" href=\"#__codelineno-5-28\"></a><span class=\"w\">        </span><span class=\"nf\">maxss</span><span class=\"w\">   </span><span class=\"nv\">%xmm7</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%xmm0</span><span class=\"w\">      </span><span class=\"c1\"># xmm0 = max(a0, b0)</span>\n</span><span id=\"__span-5-29\"><a id=\"__codelineno-5-29\" name=\"__codelineno-5-29\" href=\"#__codelineno-5-29\"></a><span class=\"w\">        </span><span class=\"nf\">maxss</span><span class=\"w\">   </span><span class=\"nv\">%xmm5</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%xmm3</span><span class=\"w\">      </span><span class=\"c1\"># xmm3 = max(a1, b1)</span>\n</span><span id=\"__span-5-30\"><a id=\"__codelineno-5-30\" name=\"__codelineno-5-30\" href=\"#__codelineno-5-30\"></a><span class=\"w\">        </span><span class=\"nf\">unpcklps</span><span class=\"w\">        </span><span class=\"nv\">%xmm2</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%xmm1</span><span class=\"w\"> </span><span class=\"c1\"># xmm1 = a3 | b2</span>\n</span><span id=\"__span-5-31\"><a id=\"__codelineno-5-31\" name=\"__codelineno-5-31\" href=\"#__codelineno-5-31\"></a><span class=\"w\">        </span><span class=\"nf\">unpcklps</span><span class=\"w\">        </span><span class=\"nv\">%xmm3</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%xmm0</span><span class=\"w\"> </span><span class=\"c1\"># xmm0 = max(a1, b1) | max(a2, b2)</span>\n</span><span id=\"__span-5-32\"><a id=\"__codelineno-5-32\" name=\"__codelineno-5-32\" href=\"#__codelineno-5-32\"></a><span class=\"w\">        </span><span class=\"nf\">ret</span>\n</span><span id=\"__span-5-33\"><a id=\"__codelineno-5-33\" name=\"__codelineno-5-33\" href=\"#__codelineno-5-33\"></a><span class=\"nl\">.L14:</span><span class=\"w\">                             </span><span class=\"c1\"># handles a2 &gt;= b2</span>\n</span><span id=\"__span-5-34\"><a id=\"__codelineno-5-34\" name=\"__codelineno-5-34\" href=\"#__codelineno-5-34\"></a><span class=\"w\">        </span><span class=\"nf\">testb</span><span class=\"w\">   </span><span class=\"nv\">%al</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%al</span>\n</span><span id=\"__span-5-35\"><a id=\"__codelineno-5-35\" name=\"__codelineno-5-35\" href=\"#__codelineno-5-35\"></a><span class=\"w\">        </span><span class=\"nf\">jne</span><span class=\"w\">     </span><span class=\"no\">.L16</span><span class=\"w\">              </span><span class=\"c1\"># if b3 &gt; a3, jump to .L16</span>\n</span><span id=\"__span-5-36\"><a id=\"__codelineno-5-36\" name=\"__codelineno-5-36\" href=\"#__codelineno-5-36\"></a><span class=\"w\">        </span><span class=\"c1\">#3 here a2 &gt;= b2, a3 &gt;= b3</span>\n</span><span id=\"__span-5-37\"><a id=\"__codelineno-5-37\" name=\"__codelineno-5-37\" href=\"#__codelineno-5-37\"></a><span class=\"w\">        </span><span class=\"nf\">movaps</span><span class=\"w\">  </span><span class=\"nv\">%xmm6</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%xmm1</span><span class=\"w\">      </span><span class=\"c1\"># xmm1 = a2</span>\n</span><span id=\"__span-5-38\"><a id=\"__codelineno-5-38\" name=\"__codelineno-5-38\" href=\"#__codelineno-5-38\"></a><span class=\"w\">        </span><span class=\"c1\"># omitted below: case analysis for a2 vs b2, a3 vs b3</span>\n</span><span id=\"__span-5-39\"><a id=\"__codelineno-5-39\" name=\"__codelineno-5-39\" href=\"#__codelineno-5-39\"></a><span class=\"nl\">.L17:</span>\n</span><span id=\"__span-5-40\"><a id=\"__codelineno-5-40\" name=\"__codelineno-5-40\" href=\"#__codelineno-5-40\"></a><span class=\"w\">        </span><span class=\"nf\">maxss</span><span class=\"w\">   </span><span class=\"nv\">%xmm7</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%xmm0</span>\n</span><span id=\"__span-5-41\"><a id=\"__codelineno-5-41\" name=\"__codelineno-5-41\" href=\"#__codelineno-5-41\"></a><span class=\"w\">        </span><span class=\"nf\">maxss</span><span class=\"w\">   </span><span class=\"nv\">%xmm5</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%xmm3</span>\n</span><span id=\"__span-5-42\"><a id=\"__codelineno-5-42\" name=\"__codelineno-5-42\" href=\"#__codelineno-5-42\"></a><span class=\"w\">        </span><span class=\"nf\">unpcklps</span><span class=\"w\">        </span><span class=\"nv\">%xmm2</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%xmm1</span>\n</span><span id=\"__span-5-43\"><a id=\"__codelineno-5-43\" name=\"__codelineno-5-43\" href=\"#__codelineno-5-43\"></a><span class=\"w\">        </span><span class=\"nf\">unpcklps</span><span class=\"w\">        </span><span class=\"nv\">%xmm3</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%xmm0</span>\n</span><span id=\"__span-5-44\"><a id=\"__codelineno-5-44\" name=\"__codelineno-5-44\" href=\"#__codelineno-5-44\"></a><span class=\"w\">        </span><span class=\"nf\">ret</span>\n</span><span id=\"__span-5-45\"><a id=\"__codelineno-5-45\" name=\"__codelineno-5-45\" href=\"#__codelineno-5-45\"></a><span class=\"nl\">.L16:</span>\n</span><span id=\"__span-5-46\"><a id=\"__codelineno-5-46\" name=\"__codelineno-5-46\" href=\"#__codelineno-5-46\"></a><span class=\"w\">        </span><span class=\"nf\">movaps</span><span class=\"w\">  </span><span class=\"nv\">%xmm4</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%xmm2</span>\n</span><span id=\"__span-5-47\"><a id=\"__codelineno-5-47\" name=\"__codelineno-5-47\" href=\"#__codelineno-5-47\"></a><span class=\"w\">        </span><span class=\"nf\">movaps</span><span class=\"w\">  </span><span class=\"nv\">%xmm6</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%xmm1</span>\n</span><span id=\"__span-5-48\"><a id=\"__codelineno-5-48\" name=\"__codelineno-5-48\" href=\"#__codelineno-5-48\"></a><span class=\"w\">        </span><span class=\"nf\">jmp</span><span class=\"w\">     </span><span class=\"no\">.L17</span>\n</span><span id=\"__span-5-49\"><a id=\"__codelineno-5-49\" name=\"__codelineno-5-49\" href=\"#__codelineno-5-49\"></a><span class=\"nl\">.L15:</span>\n</span><span id=\"__span-5-50\"><a id=\"__codelineno-5-50\" name=\"__codelineno-5-50\" href=\"#__codelineno-5-50\"></a><span class=\"w\">        </span><span class=\"nf\">maxss</span><span class=\"w\">   </span><span class=\"nv\">%xmm7</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%xmm0</span>\n</span><span id=\"__span-5-51\"><a id=\"__codelineno-5-51\" name=\"__codelineno-5-51\" href=\"#__codelineno-5-51\"></a><span class=\"w\">        </span><span class=\"nf\">maxss</span><span class=\"w\">   </span><span class=\"nv\">%xmm5</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%xmm3</span>\n</span><span id=\"__span-5-52\"><a id=\"__codelineno-5-52\" name=\"__codelineno-5-52\" href=\"#__codelineno-5-52\"></a><span class=\"w\">        </span><span class=\"nf\">movaps</span><span class=\"w\">  </span><span class=\"nv\">%xmm4</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%xmm2</span>\n</span><span id=\"__span-5-53\"><a id=\"__codelineno-5-53\" name=\"__codelineno-5-53\" href=\"#__codelineno-5-53\"></a><span class=\"w\">        </span><span class=\"nf\">unpcklps</span><span class=\"w\">        </span><span class=\"nv\">%xmm2</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%xmm1</span>\n</span><span id=\"__span-5-54\"><a id=\"__codelineno-5-54\" name=\"__codelineno-5-54\" href=\"#__codelineno-5-54\"></a><span class=\"w\">        </span><span class=\"nf\">unpcklps</span><span class=\"w\">        </span><span class=\"nv\">%xmm3</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%xmm0</span>\n</span><span id=\"__span-5-55\"><a id=\"__codelineno-5-55\" name=\"__codelineno-5-55\" href=\"#__codelineno-5-55\"></a><span class=\"w\">        </span><span class=\"nf\">ret</span>\n</span></code></pre></div>\n<p>Strangely, it first extracts input values into general-purpose registers, then separately compares the last two elements a2 vs b2 and a3 vs b3, using branches to handle four possible cases (knowing where the last two max elements come from), yet still uses <code>maxss</code> for the first two elements. Why not just use <code>maxss</code> for all four elements from the start? With <code>-O3 -ffast-math</code>, it inexplicably learns this:</p>\n<div class=\"language-asm highlight\"><pre><span></span><code><span id=\"__span-6-1\"><a id=\"__codelineno-6-1\" name=\"__codelineno-6-1\" href=\"#__codelineno-6-1\"></a><span class=\"nf\">vmax</span><span class=\"p\">(</span><span class=\"no\">vfloat4</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"no\">vfloat4</span><span class=\"p\">):</span>\n</span><span id=\"__span-6-2\"><a id=\"__codelineno-6-2\" name=\"__codelineno-6-2\" href=\"#__codelineno-6-2\"></a><span class=\"w\">        </span><span class=\"nf\">movq</span><span class=\"w\">    </span><span class=\"nv\">%xmm0</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%rsi</span>\n</span><span id=\"__span-6-3\"><a id=\"__codelineno-6-3\" name=\"__codelineno-6-3\" href=\"#__codelineno-6-3\"></a><span class=\"w\">        </span><span class=\"nf\">movq</span><span class=\"w\">    </span><span class=\"nv\">%xmm1</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%rcx</span>\n</span><span id=\"__span-6-4\"><a id=\"__codelineno-6-4\" name=\"__codelineno-6-4\" href=\"#__codelineno-6-4\"></a><span class=\"w\">        </span><span class=\"nf\">movq</span><span class=\"w\">    </span><span class=\"nv\">%xmm2</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%rdx</span>\n</span><span id=\"__span-6-5\"><a id=\"__codelineno-6-5\" name=\"__codelineno-6-5\" href=\"#__codelineno-6-5\"></a><span class=\"w\">        </span><span class=\"nf\">movd</span><span class=\"w\">    </span><span class=\"nv\">%esi</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%xmm1</span>\n</span><span id=\"__span-6-6\"><a id=\"__codelineno-6-6\" name=\"__codelineno-6-6\" href=\"#__codelineno-6-6\"></a><span class=\"w\">        </span><span class=\"nf\">movq</span><span class=\"w\">    </span><span class=\"nv\">%xmm3</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%rax</span>\n</span><span id=\"__span-6-7\"><a id=\"__codelineno-6-7\" name=\"__codelineno-6-7\" href=\"#__codelineno-6-7\"></a><span class=\"w\">        </span><span class=\"nf\">movdqa</span><span class=\"w\">  </span><span class=\"nv\">%xmm2</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%xmm0</span>\n</span><span id=\"__span-6-8\"><a id=\"__codelineno-6-8\" name=\"__codelineno-6-8\" href=\"#__codelineno-6-8\"></a><span class=\"w\">        </span><span class=\"nf\">shrq</span><span class=\"w\">    </span><span class=\"no\">$32</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%rdx</span>\n</span><span id=\"__span-6-9\"><a id=\"__codelineno-6-9\" name=\"__codelineno-6-9\" href=\"#__codelineno-6-9\"></a><span class=\"w\">        </span><span class=\"nf\">maxss</span><span class=\"w\">   </span><span class=\"nv\">%xmm1</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%xmm0</span>\n</span><span id=\"__span-6-10\"><a id=\"__codelineno-6-10\" name=\"__codelineno-6-10\" href=\"#__codelineno-6-10\"></a><span class=\"w\">        </span><span class=\"nf\">shrq</span><span class=\"w\">    </span><span class=\"no\">$32</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%rsi</span>\n</span><span id=\"__span-6-11\"><a id=\"__codelineno-6-11\" name=\"__codelineno-6-11\" href=\"#__codelineno-6-11\"></a><span class=\"w\">        </span><span class=\"nf\">movdqa</span><span class=\"w\">  </span><span class=\"nv\">%xmm3</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%xmm1</span>\n</span><span id=\"__span-6-12\"><a id=\"__codelineno-6-12\" name=\"__codelineno-6-12\" href=\"#__codelineno-6-12\"></a><span class=\"w\">        </span><span class=\"nf\">shrq</span><span class=\"w\">    </span><span class=\"no\">$32</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%rax</span>\n</span><span id=\"__span-6-13\"><a id=\"__codelineno-6-13\" name=\"__codelineno-6-13\" href=\"#__codelineno-6-13\"></a><span class=\"w\">        </span><span class=\"nf\">movd</span><span class=\"w\">    </span><span class=\"nv\">%ecx</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%xmm3</span>\n</span><span id=\"__span-6-14\"><a id=\"__codelineno-6-14\" name=\"__codelineno-6-14\" href=\"#__codelineno-6-14\"></a><span class=\"w\">        </span><span class=\"nf\">shrq</span><span class=\"w\">    </span><span class=\"no\">$32</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%rcx</span>\n</span><span id=\"__span-6-15\"><a id=\"__codelineno-6-15\" name=\"__codelineno-6-15\" href=\"#__codelineno-6-15\"></a><span class=\"w\">        </span><span class=\"nf\">movd</span><span class=\"w\">    </span><span class=\"nv\">%edx</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%xmm2</span>\n</span><span id=\"__span-6-16\"><a id=\"__codelineno-6-16\" name=\"__codelineno-6-16\" href=\"#__codelineno-6-16\"></a><span class=\"w\">        </span><span class=\"nf\">movd</span><span class=\"w\">    </span><span class=\"nv\">%esi</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%xmm4</span>\n</span><span id=\"__span-6-17\"><a id=\"__codelineno-6-17\" name=\"__codelineno-6-17\" href=\"#__codelineno-6-17\"></a><span class=\"w\">        </span><span class=\"nf\">maxss</span><span class=\"w\">   </span><span class=\"nv\">%xmm3</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%xmm1</span>\n</span><span id=\"__span-6-18\"><a id=\"__codelineno-6-18\" name=\"__codelineno-6-18\" href=\"#__codelineno-6-18\"></a><span class=\"w\">        </span><span class=\"nf\">movd</span><span class=\"w\">    </span><span class=\"nv\">%ecx</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%xmm5</span>\n</span><span id=\"__span-6-19\"><a id=\"__codelineno-6-19\" name=\"__codelineno-6-19\" href=\"#__codelineno-6-19\"></a><span class=\"w\">        </span><span class=\"nf\">movd</span><span class=\"w\">    </span><span class=\"nv\">%eax</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%xmm3</span>\n</span><span id=\"__span-6-20\"><a id=\"__codelineno-6-20\" name=\"__codelineno-6-20\" href=\"#__codelineno-6-20\"></a><span class=\"w\">        </span><span class=\"nf\">maxss</span><span class=\"w\">   </span><span class=\"nv\">%xmm4</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%xmm2</span>\n</span><span id=\"__span-6-21\"><a id=\"__codelineno-6-21\" name=\"__codelineno-6-21\" href=\"#__codelineno-6-21\"></a><span class=\"w\">        </span><span class=\"nf\">maxss</span><span class=\"w\">   </span><span class=\"nv\">%xmm5</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%xmm3</span>\n</span><span id=\"__span-6-22\"><a id=\"__codelineno-6-22\" name=\"__codelineno-6-22\" href=\"#__codelineno-6-22\"></a><span class=\"w\">        </span><span class=\"nf\">unpcklps</span><span class=\"w\">        </span><span class=\"nv\">%xmm2</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%xmm0</span>\n</span><span id=\"__span-6-23\"><a id=\"__codelineno-6-23\" name=\"__codelineno-6-23\" href=\"#__codelineno-6-23\"></a><span class=\"w\">        </span><span class=\"nf\">unpcklps</span><span class=\"w\">        </span><span class=\"nv\">%xmm3</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%xmm1</span>\n</span><span id=\"__span-6-24\"><a id=\"__codelineno-6-24\" name=\"__codelineno-6-24\" href=\"#__codelineno-6-24\"></a><span class=\"w\">        </span><span class=\"nf\">ret</span>\n</span></code></pre></div>\n<p>But it still uses scalar SSE, while LLVM 22 knows how to vectorize with <code>maxps</code>:</p>\n<div class=\"language-asm highlight\"><pre><span></span><code><span id=\"__span-7-1\"><a id=\"__codelineno-7-1\" name=\"__codelineno-7-1\" href=\"#__codelineno-7-1\"></a><span class=\"nf\">vmax</span><span class=\"p\">(</span><span class=\"no\">vfloat4</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"no\">vfloat4</span><span class=\"p\">):</span>\n</span><span id=\"__span-7-2\"><a id=\"__codelineno-7-2\" name=\"__codelineno-7-2\" href=\"#__codelineno-7-2\"></a><span class=\"w\">        </span><span class=\"nf\">movlhps</span><span class=\"w\"> </span><span class=\"nv\">%xmm3</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%xmm2</span>\n</span><span id=\"__span-7-3\"><a id=\"__codelineno-7-3\" name=\"__codelineno-7-3\" href=\"#__codelineno-7-3\"></a><span class=\"w\">        </span><span class=\"nf\">movlhps</span><span class=\"w\"> </span><span class=\"nv\">%xmm1</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%xmm0</span>\n</span><span id=\"__span-7-4\"><a id=\"__codelineno-7-4\" name=\"__codelineno-7-4\" href=\"#__codelineno-7-4\"></a><span class=\"w\">        </span><span class=\"nf\">maxps</span><span class=\"w\">   </span><span class=\"nv\">%xmm2</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%xmm0</span>\n</span><span id=\"__span-7-5\"><a id=\"__codelineno-7-5\" name=\"__codelineno-7-5\" href=\"#__codelineno-7-5\"></a><span class=\"w\">        </span><span class=\"nf\">movaps</span><span class=\"w\">  </span><span class=\"nv\">%xmm0</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%xmm1</span>\n</span><span id=\"__span-7-6\"><a id=\"__codelineno-7-6\" name=\"__codelineno-7-6\" href=\"#__codelineno-7-6\"></a><span class=\"w\">        </span><span class=\"nf\">unpckhpd</span><span class=\"w\">        </span><span class=\"nv\">%xmm0</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"nv\">%xmm1</span>\n</span><span id=\"__span-7-7\"><a id=\"__codelineno-7-7\" name=\"__codelineno-7-7\" href=\"#__codelineno-7-7\"></a><span class=\"w\">        </span><span class=\"nf\">retq</span>\n</span></code></pre></div>\n<p>The remaining instructions are only for handling calling convention data placement; within the function, typically a single <code>maxps</code> instruction completes the max computation for all 4 elements. This example illustrates why LLVM 22 is so much faster than GCC 14: GCC 14 generates many useless branches for the <code>select</code> comparison and fails to vectorize the max operation. Even with <code>-march=native</code>, GCC 14 still uses AVX instructions for scalar max operations. See <a href=\"https://godbolt.org/z/Y8Ps15n39\">Godbolt</a>. GCC 14's high MPKI comes from exactly this. I also tested the same code on LoongArch, where vectorization support is similarly poor (see <a href=\"https://godbolt.org/z/qTsaMnzhe\">Godbolt</a>), so I filed an <a href=\"https://github.com/loongson-community/discussions/issues/120\">issue</a>. Considering only the vectorized fmax kernel, an optimized implementation using <code>vfcmp.slt.s</code> + <code>vbitsel.v</code> would be roughly 2.9x the performance of LLVM 22's current output. A small trivia point: x86 SSE/AVX max instructions implement <code>a &gt; b ? a : b</code> logic, while LoongArch's fmax implements IEEE754 <code>maxNum</code>. These differ when NaN is present: the former returns b whenever either a or b is NaN, while the latter returns the non-NaN value when only one operand is NaN.</p>\n<h4 id=\"2-hdr\">2. hdr</h4>\n<p>Main hotspot functions:</p>\n<ul>\n<li><code>compute_angular_endpoints_for_quant_levels</code> from <code>src/astcenc_weight_align.cpp</code>: 19.80%, see above;</li>\n<li><code>compute_avgs_and_dirs_3_comp_rgb</code> from <code>src/astcenc_averages_and_directions.cpp</code>: 15.37%, see above;</li>\n<li><code>compute_quantized_weights_for_decimation</code> from <code>src/astcenc_ideal_endpoints_and_weights.cpp</code>: 12.40%, see above;</li>\n<li><code>compute_error_squared_rgb</code> from <code>src/astcenc_averages_and_directions.cpp</code>: 6.91%, see above;</li>\n<li><code>compute_ideal_weights_for_decimation</code> from <code>src/astcenc_ideal_endpoints_and_weights.cpp</code>: 5.68%, see above.</li>\n</ul>\n<p>Hotspot functions are essentially the same as 1. linear. GCC 14 generates many branches and scalar SSE instructions, while LLVM 22 vectorizes better and avoids unnecessary branches. Comparison:</p>\n<table>\n<thead>\n<tr>\n<th>Compiler + Flags</th>\n<th>Time (s)</th>\n<th>Insns (B)</th>\n<th>Load (B)</th>\n<th>Store (B)</th>\n<th>Branch (B)</th>\n<th>FP Scalar (B)</th>\n<th>FP Vector (B)</th>\n<th>Mispred (M)</th>\n<th>MPKI</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>GCC 14 <code>-O3</code></td>\n<td>72.1</td>\n<td>1091.8</td>\n<td>306.9</td>\n<td>78.6</td>\n<td>91.7</td>\n<td>245.8</td>\n<td>30.4</td>\n<td>4928.9</td>\n<td>4.51</td>\n</tr>\n<tr>\n<td>GCC 14 <code>-O3 -march=native</code></td>\n<td>63.1</td>\n<td>851.4</td>\n<td>271.2</td>\n<td>65.2</td>\n<td>77.4</td>\n<td>240.1</td>\n<td>30.4</td>\n<td>4890.6</td>\n<td>5.74</td>\n</tr>\n<tr>\n<td>GCC 14 <code>-O3 -ffast-math</code></td>\n<td>67.1</td>\n<td>1036.6</td>\n<td>311.0</td>\n<td>85.5</td>\n<td>73.7</td>\n<td>200.8</td>\n<td>54.3</td>\n<td>4077.0</td>\n<td>3.93</td>\n</tr>\n<tr>\n<td>LLVM 22 <code>-O3</code></td>\n<td>55.9</td>\n<td>1107.9</td>\n<td>276.5</td>\n<td>55.9</td>\n<td>56.9</td>\n<td>111.8</td>\n<td>129.9</td>\n<td>1943.2</td>\n<td>1.75</td>\n</tr>\n<tr>\n<td>LLVM 22 <code>-O3 -march=native</code></td>\n<td>48.6</td>\n<td>825.2</td>\n<td>209.3</td>\n<td>30.7</td>\n<td>34.1</td>\n<td>85.2</td>\n<td>139.7</td>\n<td>1411.6</td>\n<td>1.71</td>\n</tr>\n</tbody>\n</table>\n<h4 id=\"3-precision\">3. precision</h4>\n<p>Hotspot functions are mostly the same as 1. linear and 2. hdr, with the addition of <code>find_best_partition_candidates</code> from <code>src/astcenc_find_best_partitioning.cpp</code>, where the main bottleneck is <code>a / sqrt(length)</code> computation. This time GCC 14 under <code>-O3</code> actually vectorizes this step correctly via a scalar <code>sqrtss</code>, <code>shufps</code> to broadcast the result to all lanes, then <code>divps</code> for batch division. However, other hotspot functions still produce slow code as before. Performance counter comparison:</p>\n<table>\n<thead>\n<tr>\n<th>Compiler + Flags</th>\n<th>Time (s)</th>\n<th>Insns (B)</th>\n<th>Load (B)</th>\n<th>Store (B)</th>\n<th>Branch (B)</th>\n<th>FP Scalar (B)</th>\n<th>FP Vector (B)</th>\n<th>Mispred (M)</th>\n<th>MPKI</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>GCC 14 <code>-O3</code></td>\n<td>53.8</td>\n<td>711.5</td>\n<td>176.8</td>\n<td>62.0</td>\n<td>61.3</td>\n<td>177.0</td>\n<td>9.3</td>\n<td>5119.2</td>\n<td>7.19</td>\n</tr>\n<tr>\n<td>GCC 14 <code>-O3 -march=native</code></td>\n<td>49.2</td>\n<td>570.5</td>\n<td>161.3</td>\n<td>57.1</td>\n<td>54.7</td>\n<td>176.1</td>\n<td>9.2</td>\n<td>5113.1</td>\n<td>8.96</td>\n</tr>\n<tr>\n<td>GCC 14 <code>-O3 -ffast-math</code></td>\n<td>48.7</td>\n<td>655.9</td>\n<td>168.3</td>\n<td>64.6</td>\n<td>49.8</td>\n<td>156.5</td>\n<td>19.5</td>\n<td>4227.6</td>\n<td>6.56</td>\n</tr>\n<tr>\n<td>LLVM 22 <code>-O3</code></td>\n<td>39.3</td>\n<td>729.9</td>\n<td>149.2</td>\n<td>42.8</td>\n<td>35.9</td>\n<td>75.3</td>\n<td>77.2</td>\n<td>1906.7</td>\n<td>2.61</td>\n</tr>\n<tr>\n<td>LLVM 22 <code>-O3 -march=native</code></td>\n<td>34.1</td>\n<td>544.9</td>\n<td>112.5</td>\n<td>28.0</td>\n<td>23.2</td>\n<td>52.0</td>\n<td>87.1</td>\n<td>1445.7</td>\n<td>2.65</td>\n</tr>\n</tbody>\n</table>\n<h4 id=\"summary\">Summary</h4>\n<p>731.astcenc_r uses SIMD-native programming with <code>vfloat4</code>, <code>vint4</code>, <code>vmask4</code>, etc., written with SIMD instructions in mind. Unfortunately GCC 14 fails to recognize the code's intent and utilize hardware instructions, inexplicably generating branches for the <code>select</code> function. LLVM 22 does much better, vectorizing where appropriate. Meanwhile, slightly less mainstream ISAs like LoongArch still lack adequate optimization for these code patterns, in both GCC and LLVM.</p>\n<h3 id=\"736ocio_r\">736.ocio_r</h3>\n<p>ocio stands for OpenColorIO. Similar to 731.astcenc_r, it processes images, but focuses more on color transformation rather than compression. This benchmark includes four workloads:</p>\n<div class=\"language-shell highlight\"><pre><span></span><code><span id=\"__span-8-1\"><a id=\"__codelineno-8-1\" name=\"__codelineno-8-1\" href=\"#__codelineno-8-1\"></a><span class=\"c1\"># 1. lut1d</span>\n</span><span id=\"__span-8-2\"><a id=\"__codelineno-8-2\" name=\"__codelineno-8-2\" href=\"#__codelineno-8-2\"></a>ocioperf<span class=\"w\"> </span>--spec-validation-offset<span class=\"w\"> </span><span class=\"m\">101</span><span class=\"w\"> </span>--spec-validation-stride<span class=\"w\"> </span><span class=\"m\">17</span><span class=\"w\"> </span>--spec-validation-pixels<span class=\"w\"> </span><span class=\"m\">131</span><span class=\"w\"> </span>--bitdepths<span class=\"w\"> </span>ui16<span class=\"w\"> </span>ui16<span class=\"w\"> </span>--iter<span class=\"w\"> </span><span class=\"m\">100</span><span class=\"w\"> </span>--test<span class=\"w\"> </span>-1<span class=\"w\"> </span>--transform<span class=\"w\"> </span>ctf/lut1d_halfdom.ctf\n</span><span id=\"__span-8-3\"><a id=\"__codelineno-8-3\" name=\"__codelineno-8-3\" href=\"#__codelineno-8-3\"></a><span class=\"c1\"># 2. mntr</span>\n</span><span id=\"__span-8-4\"><a id=\"__codelineno-8-4\" name=\"__codelineno-8-4\" href=\"#__codelineno-8-4\"></a>ocioperf<span class=\"w\"> </span>--spec-validation-offset<span class=\"w\"> </span><span class=\"m\">202</span><span class=\"w\"> </span>--spec-validation-stride<span class=\"w\"> </span><span class=\"m\">19</span><span class=\"w\"> </span>--spec-validation-pixels<span class=\"w\"> </span><span class=\"m\">132</span><span class=\"w\"> </span>--bitdepths<span class=\"w\"> </span>ui16<span class=\"w\"> </span>f32<span class=\"w\"> </span>--iter<span class=\"w\"> </span><span class=\"m\">200</span><span class=\"w\"> </span>--8kres<span class=\"w\"> </span>--test<span class=\"w\"> </span><span class=\"m\">0</span><span class=\"w\"> </span>--transform<span class=\"w\"> </span>ctf/mntr_srgb_identity.ctf\n</span><span id=\"__span-8-5\"><a id=\"__codelineno-8-5\" name=\"__codelineno-8-5\" href=\"#__codelineno-8-5\"></a><span class=\"c1\"># 3. aces</span>\n</span><span id=\"__span-8-6\"><a id=\"__codelineno-8-6\" name=\"__codelineno-8-6\" href=\"#__codelineno-8-6\"></a>ocioperf<span class=\"w\"> </span>--spec-validation-offset<span class=\"w\"> </span><span class=\"m\">303</span><span class=\"w\"> </span>--spec-validation-stride<span class=\"w\"> </span><span class=\"m\">23</span><span class=\"w\"> </span>--spec-validation-pixels<span class=\"w\"> </span><span class=\"m\">133</span><span class=\"w\"> </span>--bitdepths<span class=\"w\"> </span>f32<span class=\"w\"> </span>f32<span class=\"w\"> </span>--iter<span class=\"w\"> </span><span class=\"m\">20</span><span class=\"w\"> </span>--8kres<span class=\"w\"> </span>--test<span class=\"w\"> </span>-1<span class=\"w\"> </span>--transform<span class=\"w\"> </span>clf/aces_to_video_with_look.clf\n</span><span id=\"__span-8-7\"><a id=\"__codelineno-8-7\" name=\"__codelineno-8-7\" href=\"#__codelineno-8-7\"></a><span class=\"c1\"># 4. heavy</span>\n</span><span id=\"__span-8-8\"><a id=\"__codelineno-8-8\" name=\"__codelineno-8-8\" href=\"#__codelineno-8-8\"></a>ocioperf<span class=\"w\"> </span>--spec-validation-offset<span class=\"w\"> </span><span class=\"m\">404</span><span class=\"w\"> </span>--spec-validation-stride<span class=\"w\"> </span><span class=\"m\">29</span><span class=\"w\"> </span>--spec-validation-pixels<span class=\"w\"> </span><span class=\"m\">134</span><span class=\"w\"> </span>--bitdepths<span class=\"w\"> </span>f32<span class=\"w\"> </span>f32<span class=\"w\"> </span>--iter<span class=\"w\"> </span><span class=\"m\">25</span><span class=\"w\"> </span>--test<span class=\"w\"> </span>-1<span class=\"w\"> </span>--transform<span class=\"w\"> </span>clf/heavy_transform.clf\n</span></code></pre></div>\n<p>reftime is 875s. Performance under different compilers and flags:</p>\n<table>\n<thead>\n<tr>\n<th>Compiler + Flags</th>\n<th>Total Time (s)</th>\n<th>1. lut1d (s)</th>\n<th>2. mntr (s)</th>\n<th>3. aces (s)</th>\n<th>4. heavy (s)</th>\n<th>Score</th>\n<th>Improvement over GCC 14 <code>-O3</code> (%)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>GCC 14 <code>-O3</code></td>\n<td>139.8</td>\n<td>6.1</td>\n<td>11.2</td>\n<td>67.8</td>\n<td>54.6</td>\n<td>6.26</td>\n<td>0</td>\n</tr>\n<tr>\n<td>GCC 14 <code>-O3 -march=native</code></td>\n<td>105.0</td>\n<td>4.2</td>\n<td>10.2</td>\n<td>49.6</td>\n<td>40.1</td>\n<td>8.33</td>\n<td>33</td>\n</tr>\n<tr>\n<td>GCC 14 <code>-O3 -ffast-math</code></td>\n<td>139.4</td>\n<td>6.4</td>\n<td>11.4</td>\n<td>67.8</td>\n<td>53.9</td>\n<td>6.28</td>\n<td>0.3</td>\n</tr>\n<tr>\n<td>LLVM 22 <code>-O3</code></td>\n<td>128.9</td>\n<td>6.8</td>\n<td>11.3</td>\n<td>61.7</td>\n<td>49.0</td>\n<td>6.79</td>\n<td>8</td>\n</tr>\n<tr>\n<td>LLVM 22 <code>-O3 -march=native</code></td>\n<td>105.3</td>\n<td>5.4</td>\n<td>9.6</td>\n<td>49.3</td>\n<td>40.9</td>\n<td>8.31</td>\n<td>33</td>\n</tr>\n</tbody>\n</table>\n<p>Again, <code>-O3 -march=native</code> brings significant improvement. LLVM 22 still has a performance edge over GCC 14 under <code>-O3</code>, but they're essentially equal under <code>-O3 -march=native</code>. Detailed analysis below.</p>\n<h4 id=\"1-lut1d\">1. lut1d</h4>\n<p>Hotspot functions:</p>\n<ul>\n<li><code>OpenColorIO_v2_2dev::BitDepthCast&lt;BIT_DEPTH_F32, BIT_DEPTH_UINT16&gt;::apply</code> from <code>src/ASWF-OpenColorIO/src/OpenColorIO/CPUProcessor.cpp</code>: 45.16%, in a loop over float elements in the [0, 1] range, multiplies by 65535 to scale to uint16_t range, adds 0.5, clamps to uint16_t range, then converts float to uint16_t. Compiled to SSE vector instructions;</li>\n<li><code>OpenColorIO_v2_2dev::Lut1DRendererHalfCode&lt;BIT_DEPTH_UINT16, BIT_DEPTH_F32&gt;::apply</code> from <code>src/ASWF-OpenColorIO/src/OpenColorIO/ops/lut1d/Lut1DOpCPU.cpp</code>: 33.70%, loops over input uint16_t values doing table lookup (reading float values from a precomputed array indexed by uint16_t), bottleneck is SSE scalar indirect memory access;</li>\n<li><code>__memmove_avx_unaligned_erms</code> from libc: 13.28%, AVX-accelerated memmove;</li>\n<li><code>__memset_avx2_unaligned_erms</code> from libc: 3.55%, AVX-accelerated memset.</li>\n</ul>\n<p>For this highly vectorizable code, <code>-O3 -march=native</code> improvement is substantial. In <code>OpenColorIO_v2_2dev::BitDepthCast&lt;BIT_DEPTH_F32, BIT_DEPTH_UINT16&gt;::apply</code>, it uses AVX2 256-bit vector computation and FMA instructions to fuse the scale and add-0.5 steps, followed by bitwise operations for clamping. This function's time share drops to 27.82% under <code>-O3 -march=native</code>, making the still-scalar-SSE <code>OpenColorIO_v2_2dev::Lut1DRendererHalfCode&lt;BIT_DEPTH_UINT16, BIT_DEPTH_F32&gt;::apply</code> the primary bottleneck at 42.85%.</p>\n<p>In this sub-benchmark, GCC 14 is slightly faster than LLVM 22. Comparison:</p>\n<table>\n<thead>\n<tr>\n<th>Compiler + Flags</th>\n<th>Time (s)</th>\n<th>Insns (B)</th>\n<th>Load (B)</th>\n<th>Store (B)</th>\n<th>Branch (B)</th>\n<th>FP Scalar (B)</th>\n<th>FP Vector (B)</th>\n<th>Mispred (M)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>GCC 14 <code>-O3</code></td>\n<td>6.1</td>\n<td>106.2</td>\n<td>23.3</td>\n<td>11.7</td>\n<td>4.2</td>\n<td>2.6</td>\n<td>5.0</td>\n<td>2.6</td>\n</tr>\n<tr>\n<td>GCC 14 <code>-O3 -march=native</code></td>\n<td>4.2</td>\n<td>63.8</td>\n<td>22.0</td>\n<td>11.0</td>\n<td>3.6</td>\n<td>2.6</td>\n<td>2.5</td>\n<td>2.5</td>\n</tr>\n<tr>\n<td>GCC 14 <code>-O3 -ffast-math</code></td>\n<td>6.4</td>\n<td>104.8</td>\n<td>23.2</td>\n<td>11.7</td>\n<td>4.2</td>\n<td>2.5</td>\n<td>5.0</td>\n<td>2.6</td>\n</tr>\n<tr>\n<td>LLVM 22 <code>-O3</code></td>\n<td>6.8</td>\n<td>106.1</td>\n<td>23.3</td>\n<td>11.7</td>\n<td>3.6</td>\n<td>2.5</td>\n<td>5.0</td>\n<td>2.6</td>\n</tr>\n<tr>\n<td>LLVM 22 <code>-O3 -march=native</code></td>\n<td>5.4</td>\n<td>72.5</td>\n<td>24.8</td>\n<td>11.0</td>\n<td>1.4</td>\n<td>2.5</td>\n<td>2.5</td>\n<td>2.5</td>\n</tr>\n</tbody>\n</table>\n<p>At the assembly level, GCC 14 and LLVM 22 differ in implementation. Both start with multiplication and addition, but differ in the clamping portion for handling 16-to-32-bit width conversion: GCC 14 mainly uses punpcklwd-type instructions, while LLVM 22 prefers pshufd-type instructions (see <a href=\"https://godbolt.org/z/KP3vznq1j\">Godbolt</a>). Although total instruction counts are close, different instructions require different execution times on hardware, resulting in some IPC difference. Similar situation after enabling <code>-O3 -march=native</code>.</p>\n<h4 id=\"2-mntr\">2. mntr</h4>\n<p>Hotspot functions:</p>\n<ul>\n<li><code>OpenColorIO_v2_2dev::BitDepthCast&lt;BIT_DEPTH_UINT16, BIT_DEPTH_F32&gt;::apply</code> from <code>src/ASWF-OpenColorIO/src/OpenColorIO/CPUProcessor.cpp</code>: 55.41%, this time converting from uint16_t to float, so the computation becomes converting uint16_t to float then multiplying by <code>1.0/65535.0</code> (no clamping needed). The compiler vectorizes correctly, though the 16-to-32-bit width conversion takes considerable effort;</li>\n<li><code>OpenColorIO_v2_2dev::ScaleRenderer::apply</code> from <code>src/ASWF-OpenColorIO/src/OpenColorIO/ops/matrix/MatrixOpCPU.cpp</code>: 41.52%, simple per-pixel scaling of four components (from <code>out[0] = in[0] * m_scale[0]</code> to <code>out[3] = in[3] * m_scale[3]</code>). All pixels share the same <code>m_scale</code> array, which should be easy to vectorize, but it isn't because the pointers lack <code>restrict</code> annotations. The compiler cannot determine whether <code>out</code> and <code>m_scale</code> might alias; only if they don't overlap can it directly vectorize with mulps (see <a href=\"https://godbolt.org/z/E6nqrK48a\">Godbolt</a>).</li>\n</ul>\n<p>Since AMD64 lacks vector instructions for mixed-width computation, much overhead goes to shuffling data between vectors rather than actual computation and memory access. RISC-V Vector's design does produce more concise instruction sequences here (see <a href=\"https://godbolt.org/z/qvzMK47rf\">Godbolt</a>). Comparison:</p>\n<table>\n<thead>\n<tr>\n<th>Compiler + Flags</th>\n<th>Time (s)</th>\n<th>Insns (B)</th>\n<th>Load (B)</th>\n<th>Store (B)</th>\n<th>Branch (B)</th>\n<th>FP Scalar (B)</th>\n<th>FP Vector (B)</th>\n<th>Mispred (M)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>GCC 14 <code>-O3</code></td>\n<td>11.2</td>\n<td>209.9</td>\n<td>56.5</td>\n<td>33.3</td>\n<td>7.5</td>\n<td>26.8</td>\n<td>6.6</td>\n<td>1.9</td>\n</tr>\n<tr>\n<td>GCC 14 <code>-O3 -march=native</code></td>\n<td>10.2</td>\n<td>159.6</td>\n<td>54.8</td>\n<td>29.9</td>\n<td>7.1</td>\n<td>26.8</td>\n<td>3.3</td>\n<td>1.8</td>\n</tr>\n<tr>\n<td>GCC 14 <code>-O3 -ffast-math</code></td>\n<td>11.4</td>\n<td>209.7</td>\n<td>56.5</td>\n<td>33.3</td>\n<td>7.5</td>\n<td>26.7</td>\n<td>6.6</td>\n<td>1.8</td>\n</tr>\n<tr>\n<td>LLVM 22 <code>-O3</code></td>\n<td>11.3</td>\n<td>194.5</td>\n<td>56.5</td>\n<td>33.3</td>\n<td>8.6</td>\n<td>26.5</td>\n<td>6.7</td>\n<td>1.9</td>\n</tr>\n<tr>\n<td>LLVM 22 <code>-O3 -march=native</code></td>\n<td>9.6</td>\n<td>149.4</td>\n<td>58.2</td>\n<td>29.9</td>\n<td>2.8</td>\n<td>26.5</td>\n<td>3.4</td>\n<td>2.0</td>\n</tr>\n</tbody>\n</table>\n<h4 id=\"3-aces\">3. aces</h4>\n<p>Hotspot functions:</p>\n<ul>\n<li><code>OpenColorIO_v2_2dev::Lut3DTetrahedralRenderer::apply</code> from <code>src/ASWF-OpenColorIO/src/OpenColorIO/ops/lut3d/Lut3DOpCPU.cpp</code>: 50.74%, complex operations per element: multiply, clamp, floor and ceil converted to int, then index-based table lookup with indirect memory access, followed by weighted averaging. Low vectorization;</li>\n<li><code>OpenColorIO_v2_2dev::MatrixRenderer::apply</code> from <code>src/ASWF-OpenColorIO/src/OpenColorIO/ops/matrix/MatrixOpCPU.cpp</code>: 11.55%, matrix operations multiplying input 4D vectors by a 4x4 matrix. High vectorization;</li>\n<li><code>__log2f_fma</code> from libm: 10.02%, computing float log2;</li>\n<li><code>OpenColorIO_v2_2dev::CameraLin2LogRenderer::apply</code> from <code>src/ASWF-OpenColorIO/src/OpenColorIO/ops/log/LogOpCPU.cpp</code>: 9.76%, checks input range; if below threshold <code>m_linb</code>, uses linear multiply-add; otherwise calls log2 combined with multiply-add and max operations. Low vectorization.</li>\n</ul>\n<p>Comparison:</p>\n<table>\n<thead>\n<tr>\n<th>Compiler + Flags</th>\n<th>Time (s)</th>\n<th>Insns (B)</th>\n<th>Load (B)</th>\n<th>Store (B)</th>\n<th>Branch (B)</th>\n<th>FP Scalar (B)</th>\n<th>FP Vector (B)</th>\n<th>Mispred (M)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>GCC 14 <code>-O3</code></td>\n<td>67.8</td>\n<td>1258.9</td>\n<td>299.3</td>\n<td>86.3</td>\n<td>100.5</td>\n<td>260.6</td>\n<td>28.0</td>\n<td>146.6</td>\n</tr>\n<tr>\n<td>GCC 14 <code>-O3 -march=native</code></td>\n<td>49.6</td>\n<td>873.7</td>\n<td>289.0</td>\n<td>84.9</td>\n<td>84.0</td>\n<td>257.4</td>\n<td>14.0</td>\n<td>135.4</td>\n</tr>\n<tr>\n<td>GCC 14 <code>-O3 -ffast-math</code></td>\n<td>67.8</td>\n<td>1251.5</td>\n<td>296.4</td>\n<td>94.4</td>\n<td>109.9</td>\n<td>213.7</td>\n<td>43.8</td>\n<td>150.6</td>\n</tr>\n<tr>\n<td>LLVM 22 <code>-O3</code></td>\n<td>61.7</td>\n<td>1152.4</td>\n<td>416.6</td>\n<td>136.7</td>\n<td>133.7</td>\n<td>329.0</td>\n<td>15.4</td>\n<td>168.5</td>\n</tr>\n<tr>\n<td>LLVM 22 <code>-O3 -march=native</code></td>\n<td>49.3</td>\n<td>857.8</td>\n<td>342.8</td>\n<td>92.6</td>\n<td>84.4</td>\n<td>329.0</td>\n<td>13.0</td>\n<td>151.6</td>\n</tr>\n</tbody>\n</table>\n<p>The performance gap between GCC 14 and LLVM 22 under <code>-O3</code> mainly comes from floor/ceil handling: GCC 14 generates a complex series of SSE instructions (lacking SSE4.1's roundps), while LLVM 22 calls libm's <code>__floorf_sse41</code>, whose function body is essentially a single SSE4.1 roundps instruction plus return. Although there's function call overhead (call/ret plus register save/restore with extra Loads and Stores), it's still a net win. However, on processors truly without SSE4.1, GCC 14's approach would be faster. This trade-off cannot be resolved without <code>-march=native</code>; one can only guess which case is more probable. Today, AMD64 processors with SSE4.1 far outnumber those without.</p>\n<p>After enabling <code>-O3 -march=native</code>, the <code>vroundps</code> instruction replaces the previous ceil/floor implementations (GCC 14's vectorized approach or LLVM 22's libm calls), giving both compilers significant improvement and bringing them to the same level. FMA also successfully fuses many multiply-add computations.</p>\n<h4 id=\"4-heavy\">4. heavy</h4>\n<p>Hotspot functions:</p>\n<ul>\n<li><code>__powf_fma</code> from libm: 26.17%;</li>\n<li><code>OpenColorIO_v2_2dev::Lut3DRenderer::apply</code> from <code>src/ASWF-OpenColorIO/src/OpenColorIO/ops/lut3d/Lut3DOpCPU.cpp</code>: 25.69%, similar pattern to <code>Lut3DTetrahedralRenderer::apply</code> above with clamp/floor/ceil and table lookup, just with different final computation, all scalar SSE;</li>\n<li><code>OpenColorIO_v2_2dev::Lut1DRenderer&lt;BIT_DEPTH_F32, BIT_DEPTH_F32&gt;::apply</code> from <code>src/ASWF-OpenColorIO/src/OpenColorIO/ops/lut1d/Lut1DOpCPU.cpp</code>: 15.63%, similar to <code>Lut3DRenderer::apply</code> but simpler 1D table lookup, still all scalar;</li>\n<li><code>OpenColorIO_v2_2dev::CDLRendererFwd&lt;true&gt;::apply</code>: 10.88%, calls pow (causing <code>__powf_fma</code>'s high share), plus floating-point multiply, add/sub, and clamp. All scalar;</li>\n<li><code>OpenColorIO_v2_2dev::GammaMoncurveOpCPUFwd::apply</code>: 5.41%, also calls pow, with additional floating-point operations and comparisons.</li>\n</ul>\n<p>Comparison:</p>\n<table>\n<thead>\n<tr>\n<th>Compiler + Flags</th>\n<th>Time (s)</th>\n<th>Insns (B)</th>\n<th>Load (B)</th>\n<th>Store (B)</th>\n<th>Branch (B)</th>\n<th>FP Scalar (B)</th>\n<th>FP Vector (B)</th>\n<th>Mispred (M)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>GCC 14 <code>-O3</code></td>\n<td>54.6</td>\n<td>1013.5</td>\n<td>209.4</td>\n<td>57.0</td>\n<td>80.8</td>\n<td>253.7</td>\n<td>5.8</td>\n<td>32.0</td>\n</tr>\n<tr>\n<td>GCC 14 <code>-O3 -march=native</code></td>\n<td>40.9</td>\n<td>764.7</td>\n<td>204.0</td>\n<td>54.8</td>\n<td>70.8</td>\n<td>260.2</td>\n<td>3.3</td>\n<td>31.8</td>\n</tr>\n<tr>\n<td>GCC 14 <code>-O3 -ffast-math</code></td>\n<td>53.9</td>\n<td>971.0</td>\n<td>202.1</td>\n<td>50.5</td>\n<td>80.6</td>\n<td>252.3</td>\n<td>6.6</td>\n<td>29.1</td>\n</tr>\n<tr>\n<td>LLVM 22 <code>-O3</code></td>\n<td>49.0</td>\n<td>861.5</td>\n<td>250.4</td>\n<td>77.3</td>\n<td>102.7</td>\n<td>215.6</td>\n<td>29.9</td>\n<td>28.8</td>\n</tr>\n<tr>\n<td>LLVM 22 <code>-O3 -march=native</code></td>\n<td>40.9</td>\n<td>726.8</td>\n<td>206.9</td>\n<td>55.4</td>\n<td>67.3</td>\n<td>255.6</td>\n<td>25.7</td>\n<td>28.5</td>\n</tr>\n</tbody>\n</table>\n<p>The performance difference between LLVM 22 and GCC 14 is the same as in 3. aces: ceil/floor handling. Additionally, like 731.astcenc_r, for vectorized min/max operations, LLVM 22 correctly vectorizes to maxps/minps while GCC 14 produces verbose code.</p>\n<h4 id=\"summary_1\">Summary</h4>\n<p>736.ocio_r is another application well-suited for vectorization. Although it doesn't use <code>vfloat4</code> directly like 731.astcenc_r, it's image processing where each loop iteration handles one pixel with four channels. In many cases these four channels undergo identical computation, making it very amenable to vectorization. LLVM 22 under <code>-O3</code> generates better code than GCC 14, from floor/ceil mapping to libm functions to better vectorization. However, with <code>-O3 -march=native</code>, the performance gap between GCC 14 and LLVM 22 becomes negligible, indicating that with sufficient ISA extensions enabled, both converge to similar implementations. This also suggests GCC 14's SSE code generation has deficiencies: perhaps it's not that GCC 14 cannot vectorize (since it does so with <code>-O3 -march=native</code>), but rather it doesn't know how to express vectorized code with SSE after attempting vectorization, so it falls back to scalar.</p>\n<h3 id=\"737gmsh_r\">737.gmsh_r</h3>\n<p>737.gmsh_r is a 3D CAD meshing software with seven workloads:</p>\n<div class=\"language-shell highlight\"><pre><span></span><code><span id=\"__span-9-1\"><a id=\"__codelineno-9-1\" name=\"__codelineno-9-1\" href=\"#__codelineno-9-1\"></a><span class=\"c1\"># 1. choi</span>\n</span><span id=\"__span-9-2\"><a id=\"__codelineno-9-2\" name=\"__codelineno-9-2\" href=\"#__codelineno-9-2\"></a>gmsh_r<span class=\"w\"> </span>-option<span class=\"w\"> </span>gmsh.opts<span class=\"w\"> </span>-nt<span class=\"w\"> </span><span class=\"m\">0</span><span class=\"w\"> </span>choi.geo\n</span><span id=\"__span-9-3\"><a id=\"__codelineno-9-3\" name=\"__codelineno-9-3\" href=\"#__codelineno-9-3\"></a><span class=\"c1\"># 2. mediterranean</span>\n</span><span id=\"__span-9-4\"><a id=\"__codelineno-9-4\" name=\"__codelineno-9-4\" href=\"#__codelineno-9-4\"></a>gmsh_r<span class=\"w\"> </span>-option<span class=\"w\"> </span>gmsh.opts<span class=\"w\"> </span>-nt<span class=\"w\"> </span><span class=\"m\">0</span><span class=\"w\"> </span>mediterranean.geo\n</span><span id=\"__span-9-5\"><a id=\"__codelineno-9-5\" name=\"__codelineno-9-5\" href=\"#__codelineno-9-5\"></a><span class=\"c1\"># 3. projection</span>\n</span><span id=\"__span-9-6\"><a id=\"__codelineno-9-6\" name=\"__codelineno-9-6\" href=\"#__codelineno-9-6\"></a>gmsh_r<span class=\"w\"> </span>-option<span class=\"w\"> </span>gmsh.opts<span class=\"w\"> </span>-nt<span class=\"w\"> </span><span class=\"m\">0</span><span class=\"w\"> </span>projection.geo\n</span><span id=\"__span-9-7\"><a id=\"__codelineno-9-7\" name=\"__codelineno-9-7\" href=\"#__codelineno-9-7\"></a><span class=\"c1\"># 4. gasdis</span>\n</span><span id=\"__span-9-8\"><a id=\"__codelineno-9-8\" name=\"__codelineno-9-8\" href=\"#__codelineno-9-8\"></a>gmsh_r<span class=\"w\"> </span>-option<span class=\"w\"> </span>gmsh.opts<span class=\"w\"> </span>-nt<span class=\"w\"> </span><span class=\"m\">0</span><span class=\"w\"> </span>gasdis.geo\n</span><span id=\"__span-9-9\"><a id=\"__codelineno-9-9\" name=\"__codelineno-9-9\" href=\"#__codelineno-9-9\"></a><span class=\"c1\"># 5. Torus</span>\n</span><span id=\"__span-9-10\"><a id=\"__codelineno-9-10\" name=\"__codelineno-9-10\" href=\"#__codelineno-9-10\"></a>gmsh_r<span class=\"w\"> </span>-option<span class=\"w\"> </span>gmsh.opts<span class=\"w\"> </span>-nt<span class=\"w\"> </span><span class=\"m\">0</span><span class=\"w\"> </span>Torus.geo\n</span><span id=\"__span-9-11\"><a id=\"__codelineno-9-11\" name=\"__codelineno-9-11\" href=\"#__codelineno-9-11\"></a><span class=\"c1\"># 6. spec</span>\n</span><span id=\"__span-9-12\"><a id=\"__codelineno-9-12\" name=\"__codelineno-9-12\" href=\"#__codelineno-9-12\"></a>gmsh_r<span class=\"w\"> </span>-option<span class=\"w\"> </span>gmsh.opts<span class=\"w\"> </span>-nt<span class=\"w\"> </span><span class=\"m\">0</span><span class=\"w\"> </span>spec.geo<span class=\"w\"> </span>-clscale<span class=\"w\"> </span><span class=\"m\">0</span>.175<span class=\"w\"> </span>-algo<span class=\"w\"> </span>del2d<span class=\"w\"> </span>-algo<span class=\"w\"> </span>hxt\n</span><span id=\"__span-9-13\"><a id=\"__codelineno-9-13\" name=\"__codelineno-9-13\" href=\"#__codelineno-9-13\"></a><span class=\"c1\"># 7. p19</span>\n</span><span id=\"__span-9-14\"><a id=\"__codelineno-9-14\" name=\"__codelineno-9-14\" href=\"#__codelineno-9-14\"></a>gmsh_r<span class=\"w\"> </span>-option<span class=\"w\"> </span>gmsh.opts<span class=\"w\"> </span>-nt<span class=\"w\"> </span><span class=\"m\">0</span><span class=\"w\"> </span>p19.geo\n</span></code></pre></div>\n<p>Workload runtimes are 17.1s, 11.8s, 11.2s, 16.9s, 9.2s, 13.4s, and 12.8s, totaling 92.2s, reftime 459s, corresponding to 4.98 points. Both <code>-O3 -ffast-math</code> and <code>-O3 -march=native</code> yield minimal benefit; LLVM 22 is actually slower than GCC 14, so detailed comparison is omitted.</p>\n<p>When compiling with <code>-O3 -march=native</code>, if CC is set to just <code>gcc</code> without passing <code>-std=c18</code>, the 4. gasdis workload enters an infinite loop, continuously reporting: <code>Info    : Symbolic perturbation failed (2 superposed vertices ?)</code>. The difference is whether FMA contraction occurs: with <code>-O3 -std=c18 -march=native</code>, contraction doesn't happen; with <code>-O3 -march=native</code> or <code>-O3 -std=gnu18 -march=native</code>, it does (see <a href=\"https://godbolt.org/z/58fTP5fnG\">Godbolt</a>). In other programs FMA contraction improves performance, but here it unfortunately causes an infinite loop. This relates to <a href=\"https://gcc.gnu.org/onlinedocs/gcc/Optimize-Options.html\"><code>-fp-contract</code></a>:</p>\n<div class=\"language-text highlight\"><pre><span></span><code><span id=\"__span-10-1\"><a id=\"__codelineno-10-1\" name=\"__codelineno-10-1\" href=\"#__codelineno-10-1\"></a>-ffp-contract=style\n</span><span id=\"__span-10-2\"><a id=\"__codelineno-10-2\" name=\"__codelineno-10-2\" href=\"#__codelineno-10-2\"></a>\n</span><span id=\"__span-10-3\"><a id=\"__codelineno-10-3\" name=\"__codelineno-10-3\" href=\"#__codelineno-10-3\"></a>    -ffp-contract=off disables floating-point expression contraction. -ffp-contract=fast enables floating-point expression contraction such as forming of fused multiply-add operations if the target has native support for them. -ffp-contract=on enables floating-point expression contraction if allowed by the language standard. This is implemented for C and C++, where it enables contraction within one expression, but not across different statements.\n</span><span id=\"__span-10-4\"><a id=\"__codelineno-10-4\" name=\"__codelineno-10-4\" href=\"#__codelineno-10-4\"></a>\n</span><span id=\"__span-10-5\"><a id=\"__codelineno-10-5\" name=\"__codelineno-10-5\" href=\"#__codelineno-10-5\"></a>    The default is -ffp-contract=off for C in a standards compliant mode (-std=c11 or similar), -ffp-contract=fast otherwise.\n</span></code></pre></div>\n<p>This only affects C code, not C++, so in practice only 737.gmsh_r is affected. Although 709.cactus_r also has C code, its main computation is in C++.</p>\n<p>Per-workload hotspot analysis follows.</p>\n<h4 id=\"1-choi\">1. choi</h4>\n<p>Hotspot functions:</p>\n<ul>\n<li><code>netgen::ADTree6::GetIntersecting</code> from <code>src/gmsh/contrib/Netgen/libsrc/gprim/adtree.cpp</code>: 18.40%, implements a 6-dimensional KD-Tree search algorithm. Main bottleneck is the data-dependent branch <code>if (node-&gt;pi != -1)</code> with high misprediction rate;</li>\n<li><code>__ieee754_atan2_fma</code> from libm: 6.64%;</li>\n<li><code>reparamMeshVertexOnFace</code> from <code>src/gmsh/src/geo/MVertex.cpp</code>: 6.03%, enters different <code>if-else</code> branches based on vertex dimension, with significant mispredictions.</li>\n</ul>\n<p>Although floating-point is used, the computation pattern doesn't lend itself to vectorization. KD-Tree search naturally has high MPKI. Executed 204.7B instructions with 744.3M mispredictions, MPKI = <code>744.3M/204.7B*1000=3.64</code>, second highest in SPEC FP 2026 Rate. The highest, 731.astcenc_r, is essentially due to GCC's poor implementation as discussed above; it could be optimized to around LLVM 22's 1.3, which would make 737.gmsh_r first.</p>\n<h4 id=\"2-mediterranean\">2. mediterranean</h4>\n<p>Hotspot functions:</p>\n<ul>\n<li><code>meshGEdgeProcessing</code> from <code>src/gmsh/src/mesh/meshGEdge.cpp</code>: 36.55%, main bottleneck is Gauss-Seidel iteration in a loop, where scalar division and comparisons take considerable time;</li>\n<li><code>KDTreeSingleIndexAdaptor::searchLevel</code> from <code>src/gmsh/src/numeric/nanoflann.hpp</code>: 33.50%, another classic KD-Tree search, recursing into left or right subtrees based on input value;</li>\n<li><code>InterpolateCurve</code> from <code>src/gmsh/src/geo/GeoInterpolation.cpp</code>: 6.53%, recursive interpolation computation.</li>\n</ul>\n<p>Although floating-point is involved, the computation pattern is not vectorization-friendly because intermediate results feed into if-branches, with additional floating-point computation inside the branches.</p>\n<h4 id=\"3-projection\">3. projection</h4>\n<p>Hotspot functions:</p>\n<ul>\n<li><code>laplaceSmoothing</code> from <code>src/gmsh/src/mesh/meshGFaceOptimize.cpp</code>: 11.73%, main bottleneck is <code>std::set</code> operations (which is backed by <code>std::map</code>), hence the <code>std::map</code> functions below;</li>\n<li><code>std::map::_M_get_insert_unique_pos</code> from libstdc++: 7.49%, <code>std::map</code> insertion algorithm;</li>\n<li><code>__ieee754_atan2_fma</code> from libm: 7.21%;</li>\n<li><code>reparamMeshVertexOnFace</code>: 6.66%, see above;</li>\n<li><code>std::map::_M_get_insert_unique</code> from libstdc++: 6.09%, <code>std::map</code> insertion;</li>\n<li><code>SetRotationMatrix</code> from <code>src/gmsh/src/geo/Geo.cpp</code>: 5.01%, multi-layer loops suitable for vectorization, and the compiler does vectorize, though time share is low.</li>\n</ul>\n<p>The main bottleneck in this workload is <code>std::map</code> operations.</p>\n<h4 id=\"4-gasdis\">4. gasdis</h4>\n<p>Hotspot functions:</p>\n<ul>\n<li><code>MakeHybridHexTetMeshConformalThroughTriHedron</code> from <code>src/gmsh/src/mesh/meshCombine3D.cpp</code>: 30.18%, main bottleneck is <code>std::map</code> searches in a loop;</li>\n<li><code>parallelDelaunay3D</code> from <code>src/gmsh/contrib/hxt/tetMesh/src/hxt_tetDelaunay.c</code>: 9.05%, Delaunay triangulation algorithm;</li>\n<li><code>hxtRefineTetrahedra</code> from <code>src/gmsh/contrib/hxt/tetMesh/src/hxt_tetRefine.c</code>: 5.18%, loop with floating-point computation including add/sub, mul/div, and sqrt.</li>\n</ul>\n<p>Bottleneck is mainly <code>std::map</code>.</p>\n<h4 id=\"5-torus-6-spec-and-7-p19\">5. Torus, 6. spec, and 7. p19</h4>\n<p>The last three workloads have the same hotspot functions as 4. gasdis.</p>\n<h4 id=\"summary_2\">Summary</h4>\n<p>Per-workload data:</p>\n<table>\n<thead>\n<tr>\n<th>Workload</th>\n<th>Time (s)</th>\n<th>Insns (B)</th>\n<th>Load (B)</th>\n<th>Store (B)</th>\n<th>Branch (B)</th>\n<th>FP Scalar (B)</th>\n<th>FP Vector (B)</th>\n<th>Mispred (M)</th>\n<th>MPKI</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1. choi</td>\n<td>17.0</td>\n<td>204.7</td>\n<td>59.3</td>\n<td>25.6</td>\n<td>39.4</td>\n<td>22.1</td>\n<td>0.3</td>\n<td>744.3</td>\n<td>3.64</td>\n</tr>\n<tr>\n<td>2. mediterranean</td>\n<td>11.7</td>\n<td>190.7</td>\n<td>57.4</td>\n<td>23.2</td>\n<td>24.0</td>\n<td>28.5</td>\n<td>2.4</td>\n<td>71.0</td>\n<td>0.37</td>\n</tr>\n<tr>\n<td>3. projection</td>\n<td>11.1</td>\n<td>109.0</td>\n<td>29.1</td>\n<td>14.4</td>\n<td>20.3</td>\n<td>13.3</td>\n<td>2.2</td>\n<td>183.0</td>\n<td>1.68</td>\n</tr>\n<tr>\n<td>4. gasdis</td>\n<td>16.9</td>\n<td>157.8</td>\n<td>46.3</td>\n<td>17.8</td>\n<td>27.6</td>\n<td>19.6</td>\n<td>0.2</td>\n<td>689.9</td>\n<td>4.37</td>\n</tr>\n<tr>\n<td>5. Torus</td>\n<td>9.2</td>\n<td>77.3</td>\n<td>21.9</td>\n<td>8.2</td>\n<td>13.4</td>\n<td>9.4</td>\n<td>0.5</td>\n<td>380.4</td>\n<td>4.92</td>\n</tr>\n<tr>\n<td>6. spec</td>\n<td>13.3</td>\n<td>101.4</td>\n<td>30.2</td>\n<td>10.8</td>\n<td>18.1</td>\n<td>10.9</td>\n<td>0.2</td>\n<td>546.1</td>\n<td>5.39</td>\n</tr>\n<tr>\n<td>7. p19</td>\n<td>12.7</td>\n<td>96.3</td>\n<td>28.8</td>\n<td>10.2</td>\n<td>17.2</td>\n<td>10.4</td>\n<td>0.1</td>\n<td>529.3</td>\n<td>5.50</td>\n</tr>\n</tbody>\n</table>\n<p>Overall MPKI is high, largely attributable to KD-Tree queries and <code>std::map</code> queries/insertions, although the tree keys are single-precision floats. Based on the analysis, the code indeed isn't suitable for vectorization, and FMA contraction is disabled since it would cause non-convergence.</p>\n<h3 id=\"748flightdm_r\">748.flightdm_r</h3>\n<p>flightdm is a flight dynamics simulator with eight workloads:</p>\n<div class=\"language-shell highlight\"><pre><span></span><code><span id=\"__span-11-1\"><a id=\"__codelineno-11-1\" name=\"__codelineno-11-1\" href=\"#__codelineno-11-1\"></a><span class=\"c1\"># 1. weather</span>\n</span><span id=\"__span-11-2\"><a id=\"__codelineno-11-2\" name=\"__codelineno-11-2\" href=\"#__codelineno-11-2\"></a>JSBSim<span class=\"w\"> </span>--nohighlight<span class=\"w\"> </span>scripts/weather-balloon2.xml\n</span><span id=\"__span-11-3\"><a id=\"__codelineno-11-3\" name=\"__codelineno-11-3\" href=\"#__codelineno-11-3\"></a><span class=\"c1\"># 2. B747</span>\n</span><span id=\"__span-11-4\"><a id=\"__codelineno-11-4\" name=\"__codelineno-11-4\" href=\"#__codelineno-11-4\"></a>JSBSim<span class=\"w\"> </span>--nohighlight<span class=\"w\"> </span>scripts/B747_script1.xml\n</span><span id=\"__span-11-5\"><a id=\"__codelineno-11-5\" name=\"__codelineno-11-5\" href=\"#__codelineno-11-5\"></a><span class=\"c1\"># 3. x153</span>\n</span><span id=\"__span-11-6\"><a id=\"__codelineno-11-6\" name=\"__codelineno-11-6\" href=\"#__codelineno-11-6\"></a>JSBSim<span class=\"w\"> </span>--nohighlight<span class=\"w\"> </span>scripts/x153.xml\n</span><span id=\"__span-11-7\"><a id=\"__codelineno-11-7\" name=\"__codelineno-11-7\" href=\"#__codelineno-11-7\"></a><span class=\"c1\"># 4. c3104</span>\n</span><span id=\"__span-11-8\"><a id=\"__codelineno-11-8\" name=\"__codelineno-11-8\" href=\"#__codelineno-11-8\"></a>JSBSim<span class=\"w\"> </span>--nohighlight<span class=\"w\"> </span>scripts/c3104.xml\n</span><span id=\"__span-11-9\"><a id=\"__codelineno-11-9\" name=\"__codelineno-11-9\" href=\"#__codelineno-11-9\"></a><span class=\"c1\"># 5. ah1s</span>\n</span><span id=\"__span-11-10\"><a id=\"__codelineno-11-10\" name=\"__codelineno-11-10\" href=\"#__codelineno-11-10\"></a>JSBSim<span class=\"w\"> </span>--nohighlight<span class=\"w\"> </span>scripts/ah1s_flight_test.xml\n</span><span id=\"__span-11-11\"><a id=\"__codelineno-11-11\" name=\"__codelineno-11-11\" href=\"#__codelineno-11-11\"></a><span class=\"c1\"># 6. orbit_torque</span>\n</span><span id=\"__span-11-12\"><a id=\"__codelineno-11-12\" name=\"__codelineno-11-12\" href=\"#__codelineno-11-12\"></a>JSBSim<span class=\"w\"> </span>--nohighlight<span class=\"w\"> </span>scripts/ball_orbit_g_torque.xml\n</span><span id=\"__span-11-13\"><a id=\"__codelineno-11-13\" name=\"__codelineno-11-13\" href=\"#__codelineno-11-13\"></a><span class=\"c1\"># 7. orbit_torque2</span>\n</span><span id=\"__span-11-14\"><a id=\"__codelineno-11-14\" name=\"__codelineno-11-14\" href=\"#__codelineno-11-14\"></a>JSBSim<span class=\"w\"> </span>--nohighlight<span class=\"w\"> </span>scripts/ball_orbit_g_torque2.xml\n</span><span id=\"__span-11-15\"><a id=\"__codelineno-11-15\" name=\"__codelineno-11-15\" href=\"#__codelineno-11-15\"></a><span class=\"c1\"># 8. orbit</span>\n</span><span id=\"__span-11-16\"><a id=\"__codelineno-11-16\" name=\"__codelineno-11-16\" href=\"#__codelineno-11-16\"></a>JSBSim<span class=\"w\"> </span>--nohighlight<span class=\"w\"> </span>scripts/ball_orbit.xml\n</span></code></pre></div>\n<p>Workload runtimes are 5.9s, 14.7s, 10.9s, 11.3s, 24.8s, 8.0s, 9.8s, and 8.4s, totaling 93.9s, reftime 716s, corresponding to 7.63 points. <code>-O3 -march=native</code> only gives 2% improvement; <code>-O3 -ljemalloc</code> provides 4%; <code>-O3 -flto</code> gives 11%. LLVM 22 is slower than GCC 14.</p>\n<h4 id=\"1-weather\">1. weather</h4>\n<p>Hotspot functions:</p>\n<ul>\n<li><code>__sincos_fma</code> from libm: 6.75%;</li>\n<li><code>__ieee754_atan2_fma</code> from libm: 6.41%;</li>\n<li><code>__strncmp_avx2</code> from libc: 5.04%;</li>\n<li><code>parse_path</code> from <code>src/JSB-FlightSim/src/simgear/props/props.cxx</code>: 4.43%, path string parsing, splitting into components;</li>\n<li><code>__ieee754_pow_fma</code> from libm: 4.05%.</li>\n</ul>\n<p>The hotspots are quite unusual: mostly libm/libc functions, and flightdm's own most time-consuming function is a path parser. Various optimization flags having no effect is unsurprising.</p>\n<h4 id=\"2-b747\">2. B747</h4>\n<p>Hotspot functions:</p>\n<ul>\n<li><code>SGPropertyNode::getDoubleValue</code> from <code>src/JSB-FlightSim/src/simgear/props/props.cxx</code>: 5.65%, appears to be parsing configuration files and extracting floating-point values;</li>\n<li><code>__ieee754_atan2_fma</code> from libm: 5.42%;</li>\n<li><code>__sincos_fma</code> from libm: 5.25%.</li>\n</ul>\n<p>Nothing interesting to analyze.</p>\n<h4 id=\"3-x153-and-4-c3104\">3. x153 and 4. c3104</h4>\n<p>Same hotspot functions as 2. B747.</p>\n<h4 id=\"5-ah1s\">5. ah1s</h4>\n<p>Hotspot functions:</p>\n<ul>\n<li><code>SGPropertyNode::getDoubleValue</code> from <code>src/JSB-FlightSim/src/simgear/props/props.cxx</code>: 8.45%, see above;</li>\n<li><code>JSBSim::aFunc::getValue</code> from <code>src/JSB-FlightSim/src/math/FGFunction.cpp</code>: 7.20%, a memoized <code>std::function</code>-like container;</li>\n<li><code>__sincos_fma</code> from libm: 6.04%;</li>\n<li><code>__ieee754_atan2_fma</code> from libm: 5.35%;</li>\n<li><code>JSBSim::FGPropertyValue::getValue</code> from <code>src/JSB-FlightSim/src/math/FGPropertyValue.cpp</code>: 5.11%, calls <code>getDoubleValue</code> above.</li>\n</ul>\n<p>The overall impression: either calling libm for transcendental functions or extracting configuration file contents.</p>\n<h4 id=\"6-orbit_torque\">6. orbit_torque</h4>\n<p>Hotspot functions:</p>\n<ul>\n<li><code>__ieee754_atan2_fma</code> from libm: 7.52%;</li>\n<li><code>__sincos_fma</code> from libm: 6.82%;</li>\n<li><code>__strncmp_avx2</code> from libc: 6.57%;</li>\n<li><code>parse_path</code> from <code>src/JSB-FlightSim/src/simgear/props/props.cxx</code>: 6.12%, path string parsing, splitting into components;</li>\n<li><code>SGPropertyNode::getChild</code> from <code>src/JSB-FlightSim/src/simgear/props/props.cxx</code>: 4.05%, traverses child nodes via string comparison to find matching children.</li>\n</ul>\n<h4 id=\"7-orbit_torque2-and-8-orbit\">7. orbit_torque2 and 8. orbit</h4>\n<p>Same hotspot functions as 6. orbit_torque.</p>\n<h4 id=\"summary_3\">Summary</h4>\n<p>748.flightdm_r is an uninteresting benchmark. Much time is spent in libm and libc functions, while its own code just traverses configuration files. I'd call it a libm benchmark. Beyond that, it behaves more like a SPEC INT 2026 Rate workload: string operations, memory allocation, many small functions and lambdas, suitable for <code>-O3 -flto</code> optimization. Per-workload data under <code>-O3</code>:</p>\n<table>\n<thead>\n<tr>\n<th>Workload</th>\n<th>Time (s)</th>\n<th>Insns (B)</th>\n<th>Load (B)</th>\n<th>Store (B)</th>\n<th>Branch (B)</th>\n<th>FP Scalar (B)</th>\n<th>FP Vector (B)</th>\n<th>Mispred (M)</th>\n<th>MPKI</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1. weather</td>\n<td>5.9</td>\n<td>106.1</td>\n<td>30.8</td>\n<td>15.4</td>\n<td>19.5</td>\n<td>12.9</td>\n<td>0.6</td>\n<td>11.6</td>\n<td>0.11</td>\n</tr>\n<tr>\n<td>2. B747</td>\n<td>14.8</td>\n<td>260.1</td>\n<td>80.0</td>\n<td>38.7</td>\n<td>49.4</td>\n<td>28.4</td>\n<td>1.7</td>\n<td>25.6</td>\n<td>0.10</td>\n</tr>\n<tr>\n<td>3. x153</td>\n<td>10.8</td>\n<td>193.3</td>\n<td>59.1</td>\n<td>28.7</td>\n<td>37.3</td>\n<td>20.0</td>\n<td>1.0</td>\n<td>20.9</td>\n<td>0.11</td>\n</tr>\n<tr>\n<td>4. c3104</td>\n<td>11.4</td>\n<td>194.6</td>\n<td>58.9</td>\n<td>29.1</td>\n<td>35.7</td>\n<td>23.9</td>\n<td>1.3</td>\n<td>18.2</td>\n<td>0.09</td>\n</tr>\n<tr>\n<td>5. ah1s</td>\n<td>24.7</td>\n<td>407.3</td>\n<td>130.0</td>\n<td>61.3</td>\n<td>77.9</td>\n<td>46.4</td>\n<td>1.6</td>\n<td>49.3</td>\n<td>0.12</td>\n</tr>\n<tr>\n<td>6. orbit_torque</td>\n<td>7.9</td>\n<td>152.8</td>\n<td>41.9</td>\n<td>22.7</td>\n<td>28.3</td>\n<td>16.3</td>\n<td>1.1</td>\n<td>24.2</td>\n<td>0.16</td>\n</tr>\n<tr>\n<td>7. orbit_torque2</td>\n<td>9.9</td>\n<td>191.4</td>\n<td>52.5</td>\n<td>28.4</td>\n<td>35.3</td>\n<td>21.0</td>\n<td>1.2</td>\n<td>17.1</td>\n<td>0.09</td>\n</tr>\n<tr>\n<td>8. orbit</td>\n<td>8.4</td>\n<td>161.6</td>\n<td>44.3</td>\n<td>23.9</td>\n<td>30.0</td>\n<td>17.2</td>\n<td>1.0</td>\n<td>16.3</td>\n<td>0.10</td>\n</tr>\n</tbody>\n</table>\n<p>Unremarkable.</p>\n<h3 id=\"749fotonik3d_r\">749.fotonik3d_r</h3>\n<p>Finally, a familiar face from SPEC FP 2017 Rate (previously 549.fotonik3d_r). fotonik3d solves Maxwell's equations in 3D space. Another physics-based benchmark; 3D PDE solvers invariably involve Stencil, and let's see if this holds. Single workload:</p>\n<div class=\"language-shell highlight\"><pre><span></span><code><span id=\"__span-12-1\"><a id=\"__codelineno-12-1\" name=\"__codelineno-12-1\" href=\"#__codelineno-12-1\"></a>fotonik3d_r\n</span></code></pre></div>\n<p>reftime is 1156s. Performance under different flags:</p>\n<table>\n<thead>\n<tr>\n<th>Compiler + Flags</th>\n<th>Time (s)</th>\n<th>Score</th>\n<th>Improvement over GCC 14 <code>-O3</code> (%)</th>\n<th>Insns (B)</th>\n<th>Load (B)</th>\n<th>Store (B)</th>\n<th>Branch (B)</th>\n<th>FP Scalar (B)</th>\n<th>FP Vector (B)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>GCC 14 <code>-O3</code></td>\n<td>131.1</td>\n<td>8.82</td>\n<td>0</td>\n<td>1408.5</td>\n<td>375.1</td>\n<td>120.7</td>\n<td>30.9</td>\n<td>5.4</td>\n<td>527.2</td>\n</tr>\n<tr>\n<td>GCC 14 <code>-O3 -march=native</code></td>\n<td>114.9</td>\n<td>10.1</td>\n<td>14</td>\n<td>670.1</td>\n<td>274.1</td>\n<td>82.4</td>\n<td>27.1</td>\n<td>5.5</td>\n<td>249.4</td>\n</tr>\n<tr>\n<td>GCC 14 <code>-O3 -ffast-math</code></td>\n<td>116.7</td>\n<td>9.91</td>\n<td>12</td>\n<td>1117.6</td>\n<td>378.4</td>\n<td>120.8</td>\n<td>30.7</td>\n<td>4.8</td>\n<td>396.2</td>\n</tr>\n<tr>\n<td>GCC 14 <code>-O3 -ffast-math -march=native</code></td>\n<td>108.5</td>\n<td>10.65</td>\n<td>21</td>\n<td>599.5</td>\n<td>276.3</td>\n<td>82.3</td>\n<td>26.9</td>\n<td>4.8</td>\n<td>204.8</td>\n</tr>\n</tbody>\n</table>\n<p>LLVM 22 performs similarly to GCC 14 and is omitted. Both <code>-O3 -march=native</code> and <code>-O3 -ffast-math</code> provide solid improvements. Hotspot analysis:</p>\n<ul>\n<li><code>power_dft</code> from <code>src/power.F90</code>: 30.92%, performs DFT (Discrete Fourier Transform), bottleneck is double-precision floating-point multiply-add in loops, compiled to SSE vector instructions by GCC 14;</li>\n<li><code>UPML_updateE_simple</code> from <code>src/UPML.F90</code>: 24.73%, 3D Stencil computation, SSE vector instructions;</li>\n<li><code>UPML_updateH</code> from <code>src/UPML.F90</code>: 23.26%, 3D Stencil computation, SSE vector instructions;</li>\n<li><code>mat_updateE</code> from <code>src/material.F90</code>: 11.04%, Stencil computation, SSE vector instructions;</li>\n<li><code>updateH</code> from <code>src/update.F90</code>: 9.78%, Stencil computation, SSE vector instructions.</li>\n</ul>\n<p>Besides <code>power_dft</code>, most time is spent on Stencil computation. This time the Stencil pattern is purer since GCC can vectorize well with SSE. Based on earlier experience, such programs benefit greatly from <code>-O3 -march=native</code>, <code>-O3 -ffast-math</code>, and their combination.</p>\n<p>With <code>-march=native</code>, wider AVX2 vectors bring higher parallelism, plus FMA instructions like <a href=\"https://www.felixcloutier.com/x86/vfmaddsub132pd:vfmaddsub213pd:vfmaddsub231pd\"><code>vfmaddsub231pd</code></a>.</p>\n<p>With <code>-O3 -ffast-math</code>, the core computation in <code>power_dft</code> is essentially complex multiplied by real, then added to complex, as shown in this Fortran code:</p>\n<div class=\"language-c highlight\"><pre><span></span><code><span id=\"__span-13-1\"><a id=\"__codelineno-13-1\" name=\"__codelineno-13-1\" href=\"#__codelineno-13-1\"></a><span class=\"n\">subroutine</span><span class=\"w\"> </span><span class=\"n\">update</span><span class=\"p\">(</span><span class=\"n\">Efreq1</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"n\">Efreq2</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"n\">expfuncE</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"n\">Efield1</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"n\">Efield2</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"n\">n</span><span class=\"p\">)</span>\n</span><span id=\"__span-13-2\"><a id=\"__codelineno-13-2\" name=\"__codelineno-13-2\" href=\"#__codelineno-13-2\"></a><span class=\"w\">  </span><span class=\"n\">implicit</span><span class=\"w\"> </span><span class=\"n\">none</span>\n</span><span id=\"__span-13-3\"><a id=\"__codelineno-13-3\" name=\"__codelineno-13-3\" href=\"#__codelineno-13-3\"></a><span class=\"w\">  </span><span class=\"n\">integer</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"n\">intent</span><span class=\"p\">(</span><span class=\"n\">in</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">::</span><span class=\"w\"> </span><span class=\"n\">n</span>\n</span><span id=\"__span-13-4\"><a id=\"__codelineno-13-4\" name=\"__codelineno-13-4\" href=\"#__codelineno-13-4\"></a><span class=\"w\">  </span><span class=\"k\">complex</span><span class=\"p\">(</span><span class=\"mi\">8</span><span class=\"p\">),</span><span class=\"w\"> </span><span class=\"n\">intent</span><span class=\"p\">(</span><span class=\"n\">inout</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">::</span><span class=\"w\"> </span><span class=\"n\">Efreq1</span><span class=\"p\">(</span><span class=\"n\">n</span><span class=\"p\">),</span><span class=\"w\"> </span><span class=\"n\">Efreq2</span><span class=\"p\">(</span><span class=\"n\">n</span><span class=\"p\">)</span>\n</span><span id=\"__span-13-5\"><a id=\"__codelineno-13-5\" name=\"__codelineno-13-5\" href=\"#__codelineno-13-5\"></a><span class=\"w\">  </span><span class=\"k\">complex</span><span class=\"p\">(</span><span class=\"mi\">8</span><span class=\"p\">),</span><span class=\"w\"> </span><span class=\"n\">intent</span><span class=\"p\">(</span><span class=\"n\">in</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">::</span><span class=\"w\"> </span><span class=\"n\">expfuncE</span><span class=\"p\">(</span><span class=\"n\">n</span><span class=\"p\">)</span>\n</span><span id=\"__span-13-6\"><a id=\"__codelineno-13-6\" name=\"__codelineno-13-6\" href=\"#__codelineno-13-6\"></a><span class=\"w\">  </span><span class=\"n\">real</span><span class=\"p\">(</span><span class=\"mi\">8</span><span class=\"p\">),</span><span class=\"w\"> </span><span class=\"n\">intent</span><span class=\"p\">(</span><span class=\"n\">in</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">::</span><span class=\"w\"> </span><span class=\"n\">Efield1</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"n\">Efield2</span>\n</span><span id=\"__span-13-7\"><a id=\"__codelineno-13-7\" name=\"__codelineno-13-7\" href=\"#__codelineno-13-7\"></a><span class=\"w\">  </span><span class=\"n\">integer</span><span class=\"w\"> </span><span class=\"o\">::</span><span class=\"w\"> </span><span class=\"n\">i</span>\n</span><span id=\"__span-13-8\"><a id=\"__codelineno-13-8\" name=\"__codelineno-13-8\" href=\"#__codelineno-13-8\"></a>\n</span><span id=\"__span-13-9\"><a id=\"__codelineno-13-9\" name=\"__codelineno-13-9\" href=\"#__codelineno-13-9\"></a><span class=\"w\">  </span><span class=\"k\">do</span><span class=\"w\"> </span><span class=\"n\">i</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span><span class=\"mi\">1</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"n\">n</span>\n</span><span id=\"__span-13-10\"><a id=\"__codelineno-13-10\" name=\"__codelineno-13-10\" href=\"#__codelineno-13-10\"></a><span class=\"w\">    </span><span class=\"n\">Efreq1</span><span class=\"p\">(</span><span class=\"n\">i</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span><span class=\"n\">Efreq1</span><span class=\"p\">(</span><span class=\"n\">i</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"n\">expfuncE</span><span class=\"p\">(</span><span class=\"n\">i</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">Efield1</span>\n</span><span id=\"__span-13-11\"><a id=\"__codelineno-13-11\" name=\"__codelineno-13-11\" href=\"#__codelineno-13-11\"></a><span class=\"w\">    </span><span class=\"n\">Efreq2</span><span class=\"p\">(</span><span class=\"n\">i</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span><span class=\"n\">Efreq2</span><span class=\"p\">(</span><span class=\"n\">i</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"n\">expfuncE</span><span class=\"p\">(</span><span class=\"n\">i</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">Efield2</span>\n</span><span id=\"__span-13-12\"><a id=\"__codelineno-13-12\" name=\"__codelineno-13-12\" href=\"#__codelineno-13-12\"></a><span class=\"w\">  </span><span class=\"n\">end</span><span class=\"w\"> </span><span class=\"k\">do</span>\n</span><span id=\"__span-13-13\"><a id=\"__codelineno-13-13\" name=\"__codelineno-13-13\" href=\"#__codelineno-13-13\"></a><span class=\"n\">end</span><span class=\"w\"> </span><span class=\"n\">subroutine</span><span class=\"w\"> </span><span class=\"n\">update</span>\n</span></code></pre></div>\n<p>Under <code>-O3</code>, GCC 14 faithfully implements complex multiplication. However, Efield1 and Efield2 are real numbers, so the converted complex has zero imaginary part. With <code>-O3 -ffast-math</code>, this simplifies to directly multiplying the real part into expfuncE's real and imaginary components. With <code>-O3 -ffast-math -march=native</code>, both optimizations combine: the AVX2 FMA instruction <code>vfmadd213pd</code> replaces the <code>vfmaddsub231pd</code> needed under <code>-O3 -march=native</code> (which simultaneously adds and subtracts; the subtraction comes from the complex multiplication definition, but subtracts zero here since Efield1/Efield2's imaginary part is zero). See <a href=\"https://godbolt.org/z/v3W4e5xjP\">Godbolt</a>.</p>\n<p>In summary, 749.fotonik3d_r is a classic floating-point application with heavy Stencil and vector floating-point operations, high parallelism, amenable to vectorization, and benefits from <code>-ffast-math</code> computation order optimization.</p>\n<h3 id=\"765roms_r\">765.roms_r</h3>\n<p>Another returnee from SPEC FP 2017 Rate (previously 554.roms_r), implementing ocean simulation. Unsurprisingly, it's Stencil again. Single workload:</p>\n<div class=\"language-shell highlight\"><pre><span></span><code><span id=\"__span-14-1\"><a id=\"__codelineno-14-1\" name=\"__codelineno-14-1\" href=\"#__codelineno-14-1\"></a>roms_r<span class=\"w\"> </span>&lt;<span class=\"w\"> </span>roms_benchmark2.in.x\n</span></code></pre></div>\n<p>reftime is 1575s. Performance:</p>\n<table>\n<thead>\n<tr>\n<th>Compiler + Flags</th>\n<th>Time (s)</th>\n<th>Score</th>\n<th>Improvement over GCC 14 <code>-O3</code> (%)</th>\n<th>Insns (B)</th>\n<th>Load (B)</th>\n<th>Store (B)</th>\n<th>Branch (B)</th>\n<th>FP Scalar (B)</th>\n<th>FP Vector (B)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>GCC 14 <code>-O3</code></td>\n<td>169.8</td>\n<td>9.28</td>\n<td>0</td>\n<td>2620.6</td>\n<td>874.8</td>\n<td>204.7</td>\n<td>192.1</td>\n<td>193.3</td>\n<td>709.2</td>\n</tr>\n<tr>\n<td>GCC 14 <code>-O3 -march=native</code></td>\n<td>149.5</td>\n<td>10.5</td>\n<td>14</td>\n<td>1317.9</td>\n<td>555.3</td>\n<td>125.0</td>\n<td>126.6</td>\n<td>164.9</td>\n<td>365.9</td>\n</tr>\n<tr>\n<td>GCC 14 <code>-O3 -ffast-math</code></td>\n<td>162.8</td>\n<td>9.67</td>\n<td>4</td>\n<td>2518.6</td>\n<td>854.5</td>\n<td>204.0</td>\n<td>178.5</td>\n<td>134.0</td>\n<td>711.7</td>\n</tr>\n<tr>\n<td>LLVM 22 <code>-O3</code></td>\n<td>165.6</td>\n<td>9.51</td>\n<td>3</td>\n<td>2434.3</td>\n<td>834.9</td>\n<td>190.3</td>\n<td>164.1</td>\n<td>231.8</td>\n<td>687.0</td>\n</tr>\n<tr>\n<td>LLVM 22 <code>-O3 -march=native</code></td>\n<td>152.1</td>\n<td>10.4</td>\n<td>12</td>\n<td>1423.4</td>\n<td>551.4</td>\n<td>131.2</td>\n<td>140.1</td>\n<td>259.8</td>\n<td>350.0</td>\n</tr>\n</tbody>\n</table>\n<p>Heavy floating-point computation with high vectorizability; <code>-O3 -march=native</code> improvement is expected.</p>\n<p>Hotspot functions:</p>\n<ul>\n<li><code>step2d_tile</code> from <code>src/step2d_LF_AM3.h</code>: 20.37%, 2D Stencil computation, high vectorization;</li>\n<li><code>pre_step3d</code> from <code>src/pre_step3d.F90</code>: 10.43%, floating-point computation in loops, high vectorization;</li>\n<li><code>lmd_skpp</code> from <code>src/lmd_skpp.F90</code>: 8.91%, complex floating-point computation in loops, mainly scalar;</li>\n<li><code>step3d_t_tile</code> from <code>src/step3d_t.F90</code>: 7.04%, 3D Stencil computation, high vectorization;</li>\n<li><code>rhs3d</code> from <code>src/rhs3d.F90</code>: 6.04%, 2D Stencil computation, high vectorization;</li>\n<li><code>t3dmix2</code> from <code>src/t3dmix2_geo.h</code>: 5.86%, 3D Stencil computation, high vectorization;</li>\n<li><code>step3d_uv_tile</code> from <code>src/step3d_uv.F90</code>: 5.85%, 3D Stencil computation, high vectorization;</li>\n<li><code>_ZGVbN2v_exp_sse4</code> from libmvec: 4.66%, vectorized exp.</li>\n</ul>\n<p>Typical Stencil computation with high vectorization. With <code>-O3 -march=native</code>, wider vectors plus FMA naturally bring solid improvements.</p>\n<h3 id=\"766femflow_r\">766.femflow_r</h3>\n<p>femflow is a fluid dynamics solver for Navier-Stokes equations. Single workload:</p>\n<div class=\"language-shell highlight\"><pre><span></span><code><span id=\"__span-15-1\"><a id=\"__codelineno-15-1\" name=\"__codelineno-15-1\" href=\"#__codelineno-15-1\"></a>femflow_r<span class=\"w\"> </span>refrate.prm\n</span></code></pre></div>\n<p>reftime is 1467s. Performance:</p>\n<table>\n<thead>\n<tr>\n<th>Compiler + Flags</th>\n<th>Time (s)</th>\n<th>Score</th>\n<th>Improvement over GCC 14 <code>-O3</code> (%)</th>\n<th>Insns (B)</th>\n<th>Load (B)</th>\n<th>Store (B)</th>\n<th>Branch (B)</th>\n<th>FP Scalar (B)</th>\n<th>FP Vector (B)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>GCC 14 <code>-O3</code></td>\n<td>188.7</td>\n<td>7.77</td>\n<td>0</td>\n<td>3862.4</td>\n<td>1358.5</td>\n<td>797.6</td>\n<td>117.5</td>\n<td>562.2</td>\n<td>676.0</td>\n</tr>\n<tr>\n<td>GCC 14 <code>-O3 -march=native</code></td>\n<td>95.1</td>\n<td>15.4</td>\n<td>98</td>\n<td>1736.9</td>\n<td>619.3</td>\n<td>356.0</td>\n<td>65.2</td>\n<td>286.8</td>\n<td>445.4</td>\n</tr>\n<tr>\n<td>GCC 16 <code>-O3</code></td>\n<td>153.6</td>\n<td>9.55</td>\n<td>23</td>\n<td>3178.6</td>\n<td>1109.3</td>\n<td>673.3</td>\n<td>127.2</td>\n<td>56.3</td>\n<td>930.9</td>\n</tr>\n<tr>\n<td>GCC 16 <code>-O3 -march=native</code></td>\n<td>83.5</td>\n<td>17.57</td>\n<td>126</td>\n<td>1457.0</td>\n<td>501.1</td>\n<td>281.4</td>\n<td>61.1</td>\n<td>47.2</td>\n<td>545.7</td>\n</tr>\n<tr>\n<td>LLVM 22 <code>-O3</code></td>\n<td>124.7</td>\n<td>11.8</td>\n<td>51</td>\n<td>2703.0</td>\n<td>857.3</td>\n<td>475.5</td>\n<td>60.6</td>\n<td>40.8</td>\n<td>930.3</td>\n</tr>\n<tr>\n<td>LLVM 22 <code>-O3 -march=native</code></td>\n<td>88.7</td>\n<td>16.5</td>\n<td>113</td>\n<td>1392.9</td>\n<td>495.7</td>\n<td>269.4</td>\n<td>42.9</td>\n<td>41.8</td>\n<td>471.1</td>\n</tr>\n</tbody>\n</table>\n<p>LLVM 22 provides significant improvement over GCC 14, and <code>-O3 -march=native</code> brings even more dramatic gains. This is the second-highest <code>-O3 -march=native</code> improvement in SPEC FP 2026 Rate (first is 772.marian_r below). GCC 16 also improves notably over GCC 14, overtaking LLVM 22 with <code>-O3 -march=native</code>.</p>\n<p>There are many hotspot functions, mostly single-digit percentage each, mainly computational operators:</p>\n<ul>\n<li><code>Laplace::LaplaceOperator::local_apply_quadratic_geo</code> from <code>src/laplace_operator.h</code>: 5.49%, heavy floating-point vector computation with high parallelism;</li>\n<li><code>operator *(const dealii::VectorizedArray &amp;, const dealii::VectorizedArray &amp;)</code> from <code>src/dealii/include/deal.ll/base/vectorization.h</code>: 5.36%, element-wise vector multiplication.</li>\n</ul>\n<p>Other functions include dealii::Tensor computations, including <code>dealii::internal::even_odd_apply</code> from <code>src/dealii/include/deal.ll/matrix_free/tensor_product_kernels.h</code>, implementing Tensor double-precision floating-point multiplication. The \"even-odd\" refers to exploiting data symmetry by splitting into even and odd parts, reducing computation count while being vectorization-friendly. For such workloads, <code>-O3 -march=native</code> provides better floating-point performance through wider vectors plus FMA.</p>\n<p>LLVM 22's advantage over GCC 14 comes from vectorizing more code: comparing instruction counts, LLVM 22 executes fewer FP scalar instructions and more FP vector instructions. GCC 16 shows a similar pattern, approaching LLVM 22's vectorization level.</p>\n<h3 id=\"767nest_r\">767.nest_r</h3>\n<p>nest is a spiking neural network simulator. This benchmark has three workloads:</p>\n<div class=\"language-shell highlight\"><pre><span></span><code><span id=\"__span-16-1\"><a id=\"__codelineno-16-1\" name=\"__codelineno-16-1\" href=\"#__codelineno-16-1\"></a><span class=\"c1\"># 1. cuba</span>\n</span><span id=\"__span-16-2\"><a id=\"__codelineno-16-2\" name=\"__codelineno-16-2\" href=\"#__codelineno-16-2\"></a>nest_r<span class=\"w\"> </span>cuba_stdp.sli\n</span><span id=\"__span-16-3\"><a id=\"__codelineno-16-3\" name=\"__codelineno-16-3\" href=\"#__codelineno-16-3\"></a><span class=\"c1\"># 2. structural</span>\n</span><span id=\"__span-16-4\"><a id=\"__codelineno-16-4\" name=\"__codelineno-16-4\" href=\"#__codelineno-16-4\"></a>nest_r<span class=\"w\"> </span>structural_plasticity_benchmark\n</span><span id=\"__span-16-5\"><a id=\"__codelineno-16-5\" name=\"__codelineno-16-5\" href=\"#__codelineno-16-5\"></a><span class=\"c1\"># 3. Artificial</span>\n</span><span id=\"__span-16-6\"><a id=\"__codelineno-16-6\" name=\"__codelineno-16-6\" href=\"#__codelineno-16-6\"></a>nest_r<span class=\"w\"> </span>ArtificialSynchrony\n</span></code></pre></div>\n<p><code>-O3 -march=native</code> gives only 3% improvement; LLVM 22 is slower than GCC 14. Per-workload data under GCC 14 <code>-O3</code>:</p>\n<table>\n<thead>\n<tr>\n<th>Workload</th>\n<th>Time (s)</th>\n<th>Insns (B)</th>\n<th>Load (B)</th>\n<th>Store (B)</th>\n<th>Branch (B)</th>\n<th>FP Scalar (B)</th>\n<th>FP Vector (B)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1. cuba</td>\n<td>14.1</td>\n<td>176.3</td>\n<td>54.5</td>\n<td>21.6</td>\n<td>22.4</td>\n<td>29.2</td>\n<td>0.0</td>\n</tr>\n<tr>\n<td>2. structural</td>\n<td>24.6</td>\n<td>413.3</td>\n<td>136.3</td>\n<td>42.8</td>\n<td>52.5</td>\n<td>93.2</td>\n<td>0.0</td>\n</tr>\n<tr>\n<td>3. Artificial</td>\n<td>48.6</td>\n<td>1125.4</td>\n<td>392.6</td>\n<td>150.5</td>\n<td>160.5</td>\n<td>163.6</td>\n<td>0.0</td>\n</tr>\n</tbody>\n</table>\n<p>Total time 87.4s, reftime 793s, corresponding to 9.07 points.</p>\n<h4 id=\"1-cuba\">1. cuba</h4>\n<p>Hotspot functions:</p>\n<ul>\n<li><code>nest::iaf_psc_exp::handle</code> from <code>src/nest-simulator/models/iaf_psc_exp.cpp</code>: 25.75%, processes incoming spikes and updates internal state. Main bottleneck is indirect memory access, writing spike weights to corresponding input buffers;</li>\n<li><code>__ieee754_pow_fma</code> from libm: 11.96%, called by <code>nest::Connector::send</code> below;</li>\n<li><code>spec::poisson_distribution::operator()</code> from <code>src/specrand-distributions/spec_random_distributions.cpp</code>: 9.87%, random number generation for input spike generation;</li>\n<li><code>nest::Connector::send</code> from <code>src/nest-simulator/nestkernel/connector_base.h</code>: 8.29%, spike propagation through synapses with STDP. Main bottleneck is indirect memory access, plus inlined weight computation with pow and exp calls;</li>\n<li><code>nest::iaf_psc_exp::update</code> from <code>src/nest-simulator/models/iaf_psc_exp.cpp</code>: 6.91%, neuron state update at each timestep, mainly scalar floating-point.</li>\n</ul>\n<p>A classic SNN simulation with STDP. Main bottlenecks are spike propagation and STDP synaptic weight updates, with very low vectorization and indirect memory access.</p>\n<h4 id=\"2-structural\">2. structural</h4>\n<p>Hotspot functions:</p>\n<ul>\n<li><code>spec::poisson_distribution::operator()</code> from <code>src/specrand-distributions/spec_random_distributions.cpp</code>: 24.26%, see above;</li>\n<li><code>nest::iaf_psc_alpha::update</code> from <code>src/nest-simulator/models/iaf_psc_alpha.cpp</code>: 13.71%, similar to <code>nest::iaf_psc_exp::update</code> but different neuron model;</li>\n<li><code>__ieee754_pow_fma</code> from libm: 13.37%, see above;</li>\n<li><code>nest::GrowthCurveGaussian::update</code> from <code>src/nest-simulator/nestkernel/growth_curve.cpp</code>: 6.60%, numerical ODE solving with frequent exp and pow calls;</li>\n<li><code>nest::iaf_psc_alpha::handle</code> from <code>src/nest-simulator/models/iaf_psc_alpha.cpp</code>: 25.75%, similar to <code>nest::iaf_psc_exp::handle</code>;</li>\n<li><code>nest::Connector::send</code> from <code>src/nest-simulator/nestkernel/connector_base.h</code>: 6.60%, see above, but without STDP this time (static weights);</li>\n<li><code>exp</code> from <code>libm</code>: 5.39%.</li>\n</ul>\n<p>Compared to 1. cuba, different neuron model without STDP. The main bottleneck shifts to Poisson distribution random generation; the rest is typical SNN simulation.</p>\n<h4 id=\"3-artificial\">3. Artificial</h4>\n<p>Hotspot functions:</p>\n<ul>\n<li><code>nest::iaf_psc_alpha_ps::update</code> from <code>src/nest-simulator/models/iaf_psc_alpha_ps.cpp</code>: 13.26%, neuron state update;</li>\n<li><code>nest::iaf_psc_alpha::update</code> from <code>src/iaf_psc_alpha.cpp</code>: 12.37%, see above;</li>\n<li><code>nest::Connector::send</code> from <code>src/nest-simulator/nestkernel/connector_base.h</code>: 7.19%, see above, still no STDP (static weights);</li>\n<li><code>nest::SimulationManager::update_</code> from <code>src/nest-simulator/nestkernel/simulation_manager.cpp</code>: 5.66%, core SNN simulation loop calling the above functions;</li>\n<li><code>__ieee754_pow_fma</code> from libm: 5.17%, see above.</li>\n</ul>\n<h4 id=\"summary_4\">Summary</h4>\n<p>nest is a flexible SNN simulator, but single-threaded performance is mediocre since most effort goes into multi-core/multi-thread optimization. Unsurprisingly, nest's neuron update code isn't vectorized, while spike propagation and STDP are inherently hard to optimize. This is a floating-point application that's difficult to vectorize; as the counters show, zero vector floating-point instructions are executed.</p>\n<h3 id=\"772marian_r\">772.marian_r</h3>\n<p>marian_r is a neural-network-based translator. Another neural network inference workload, meaning <code>-O3 -march=native</code> should have a large advantage. If dedicated hardware acceleration instructions are available (like in 706.stockfish_r), performance will far exceed <code>-O3</code>. Two workloads:</p>\n<div class=\"language-shell highlight\"><pre><span></span><code><span id=\"__span-17-1\"><a id=\"__codelineno-17-1\" name=\"__codelineno-17-1\" href=\"#__codelineno-17-1\"></a><span class=\"c1\"># 1. TildeMODEL</span>\n</span><span id=\"__span-17-2\"><a id=\"__codelineno-17-2\" name=\"__codelineno-17-2\" href=\"#__codelineno-17-2\"></a>marian-decoder<span class=\"w\"> </span>--cpu-threads<span class=\"w\"> </span><span class=\"m\">1</span><span class=\"w\"> </span>-m<span class=\"w\"> </span>model.alphas.npz<span class=\"w\"> </span>-v<span class=\"w\"> </span>vocab.spm<span class=\"w\"> </span>vocab.spm<span class=\"w\"> </span>--beam-size<span class=\"w\"> </span><span class=\"m\">1</span><span class=\"w\"> </span>--mini-batch<span class=\"w\"> </span><span class=\"m\">32</span><span class=\"w\"> </span>--maxi-batch<span class=\"w\"> </span><span class=\"m\">100</span><span class=\"w\"> </span>--maxi-batch-sort<span class=\"w\"> </span>src<span class=\"w\"> </span>-w<span class=\"w\"> </span><span class=\"m\">512</span><span class=\"w\"> </span>--skip-cost<span class=\"w\"> </span>--gemm-type<span class=\"w\"> </span>intgemm8<span class=\"w\"> </span>--intgemm-options<span class=\"w\"> </span>precomputed-alpha<span class=\"w\"> </span>standard-only<span class=\"w\"> </span>--quiet<span class=\"w\"> </span>--quiet-translation<span class=\"w\"> </span>-i<span class=\"w\"> </span>TildeMODEL-spec.en<span class=\"w\"> </span>--log<span class=\"w\"> </span>TildeMODEL-spec.log<span class=\"w\"> </span>--log-level<span class=\"w\"> </span>off<span class=\"w\"> </span>-o<span class=\"w\"> </span>TildeMODEL-spec.out\n</span><span id=\"__span-17-3\"><a id=\"__codelineno-17-3\" name=\"__codelineno-17-3\" href=\"#__codelineno-17-3\"></a><span class=\"c1\"># 2. EuroPat</span>\n</span><span id=\"__span-17-4\"><a id=\"__codelineno-17-4\" name=\"__codelineno-17-4\" href=\"#__codelineno-17-4\"></a>marian-decoder<span class=\"w\"> </span>--cpu-threads<span class=\"w\"> </span><span class=\"m\">1</span><span class=\"w\"> </span>-m<span class=\"w\"> </span>model.alphas.npz<span class=\"w\"> </span>-v<span class=\"w\"> </span>vocab.spm<span class=\"w\"> </span>vocab.spm<span class=\"w\"> </span>--beam-size<span class=\"w\"> </span><span class=\"m\">1</span><span class=\"w\"> </span>--mini-batch<span class=\"w\"> </span><span class=\"m\">32</span><span class=\"w\"> </span>--maxi-batch<span class=\"w\"> </span><span class=\"m\">100</span><span class=\"w\"> </span>--maxi-batch-sort<span class=\"w\"> </span>src<span class=\"w\"> </span>-w<span class=\"w\"> </span><span class=\"m\">512</span><span class=\"w\"> </span>--skip-cost<span class=\"w\"> </span>--gemm-type<span class=\"w\"> </span>intgemm8<span class=\"w\"> </span>--intgemm-options<span class=\"w\"> </span>precomputed-alpha<span class=\"w\"> </span>standard-only<span class=\"w\"> </span>--quiet<span class=\"w\"> </span>--quiet-translation<span class=\"w\"> </span>-i<span class=\"w\"> </span>EuroPat-spec.en<span class=\"w\"> </span>--log<span class=\"w\"> </span>EuroPat-spec.log<span class=\"w\"> </span>--log-level<span class=\"w\"> </span>off<span class=\"w\"> </span>-o<span class=\"w\"> </span>EuroPat-spec.out\n</span></code></pre></div>\n<p>reftime is 1579s. Compiler and flag comparison:</p>\n<table>\n<thead>\n<tr>\n<th>Compiler + Flags</th>\n<th>Time (s)</th>\n<th>Score</th>\n<th>Improvement over GCC 14 <code>-O3</code> (%)</th>\n<th>1. TildeMODEL (s)</th>\n<th>2. EuroPat (s)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>GCC 14 <code>-O3</code></td>\n<td>235.2</td>\n<td>6.71</td>\n<td>0</td>\n<td>88.8</td>\n<td>146.4</td>\n</tr>\n<tr>\n<td>GCC 14 <code>-O3 -march=native</code></td>\n<td>78.4</td>\n<td>20.14</td>\n<td>200</td>\n<td>28.2</td>\n<td>50.3</td>\n</tr>\n<tr>\n<td>GCC 15 <code>-O3</code></td>\n<td>150.1</td>\n<td>10.52</td>\n<td>57</td>\n<td>56.0</td>\n<td>94.8</td>\n</tr>\n<tr>\n<td>GCC 15 <code>-O3 -march=native</code></td>\n<td>77.5</td>\n<td>20.37</td>\n<td>203</td>\n<td>27.8</td>\n<td>49.7</td>\n</tr>\n</tbody>\n</table>\n<p><code>-O3 -march=native</code> provides a massive 200% improvement. On Apple M1 it's 47%, on Apple M2 it reaches 92%. This level of improvement was previously only seen in 706.stockfish_r. GCC 15 also significantly improves over GCC 14 under <code>-O3</code>.</p>\n<h4 id=\"1-tildemodel\">1. TildeMODEL</h4>\n<p>Hotspot functions:</p>\n<ul>\n<li><code>marian::cpu::integer::affineOrDotTyped</code> from <code>src/marian/tensors/cpu/intgemm_interface.h</code>: 82.28%, mainly in <code>tiled_gemm</code>, performing integer matrix multiplication: uint8_t matrix A multiplied by int8_t matrix B, accumulated to int32_t, finally converted to float and added to float matrix C;</li>\n<li><code>marian::cpu::ProdBatched</code> from <code>src/marian/tensors/cpu/prod.cpp</code>: 10.30%, core is sgemm (actual floating-point matrix operations), compiled to scalar SSE floating-point rather than vector, but given its time share, this is tolerable.</li>\n</ul>\n<p>The main hotspot has the same computation pattern as 706.stockfish_r's NNUE. With <code>-O3 -march=native</code>, AVX-VNNI's vpdpbusd instruction optimizes it (see <a href=\"https://godbolt.org/z/PTxK1evK3\">Godbolt</a>). Similarly, GCC 15 performs better than GCC 14 due to its superior unsigned extension implementation. For detailed discussion, see the 706.stockfish_r section in the <a href=\"../../22/spec-cpu-2026-workload-analysis-int-rate-en/\">INT Rate article</a>.</p>\n<p>Performance counter comparison:</p>\n<table>\n<thead>\n<tr>\n<th>Compiler + Flags</th>\n<th>Time (s)</th>\n<th>Insns (B)</th>\n<th>Load (B)</th>\n<th>Store (B)</th>\n<th>Branch (B)</th>\n<th>FP Scalar (B)</th>\n<th>FP Vector (B)</th>\n<th>128-bit Int Vec (B)</th>\n<th>256-bit Int Vec (B)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>GCC 14 <code>-O3</code></td>\n<td>88.2</td>\n<td>2038.9</td>\n<td>217.8</td>\n<td>57.8</td>\n<td>53.2</td>\n<td>58.7</td>\n<td>2.1</td>\n<td>514.6</td>\n<td>0.0</td>\n</tr>\n<tr>\n<td>GCC 14 <code>-O3 -march=native</code></td>\n<td>27.6</td>\n<td>423.0</td>\n<td>131.5</td>\n<td>25.1</td>\n<td>47.4</td>\n<td>59.8</td>\n<td>1.1</td>\n<td>12.8</td>\n<td>47.4</td>\n</tr>\n<tr>\n<td>GCC 15 <code>-O3</code></td>\n<td>55.6</td>\n<td>1353.5</td>\n<td>173.9</td>\n<td>22.1</td>\n<td>53.2</td>\n<td>58.7</td>\n<td>2.1</td>\n<td>184.7</td>\n<td>0.0</td>\n</tr>\n<tr>\n<td>GCC 15 <code>-O3 -march=native</code></td>\n<td>27.3</td>\n<td>415.1</td>\n<td>128.9</td>\n<td>23.5</td>\n<td>47.5</td>\n<td>59.8</td>\n<td>1.1</td>\n<td>12.8</td>\n<td>47.4</td>\n</tr>\n</tbody>\n</table>\n<p>128-bit integer vector from <code>int_vec_retired.128bit</code> counter, 256-bit from <code>int_vec_retired.256bit</code>.</p>\n<h4 id=\"2-europat\">2. EuroPat</h4>\n<p>Hotspot functions:</p>\n<ul>\n<li><code>marian::cpu::integer::affineOrDotTyped</code>: 78.96%, see above;</li>\n<li><code>marian::cpu::ProdBatched</code>: 14.25%, see above.</li>\n</ul>\n<p>Identical hotspots to 1. TildeMODEL; the same analysis applies. Performance counters:</p>\n<table>\n<thead>\n<tr>\n<th>Compiler + Flags</th>\n<th>Time (s)</th>\n<th>Insns (B)</th>\n<th>Load (B)</th>\n<th>Store (B)</th>\n<th>Branch (B)</th>\n<th>FP Scalar (B)</th>\n<th>FP Vector (B)</th>\n<th>128-bit Int Vec (B)</th>\n<th>256-bit Int Vec (B)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>GCC 14 <code>-O3</code></td>\n<td>145.6</td>\n<td>3352.7</td>\n<td>370.4</td>\n<td>89.7</td>\n<td>98.8</td>\n<td>123.8</td>\n<td>3.6</td>\n<td>815.0</td>\n<td>0.0</td>\n</tr>\n<tr>\n<td>GCC 14 <code>-O3 -march=native</code></td>\n<td>49.7</td>\n<td>777.2</td>\n<td>228.7</td>\n<td>36.6</td>\n<td>88.3</td>\n<td>123.9</td>\n<td>1.7</td>\n<td>19.9</td>\n<td>72.6</td>\n</tr>\n<tr>\n<td>GCC 15 <code>-O3</code></td>\n<td>94.2</td>\n<td>2268.5</td>\n<td>301.7</td>\n<td>33.1</td>\n<td>98.8</td>\n<td>123.8</td>\n<td>3.6</td>\n<td>293.6</td>\n<td>0.0</td>\n</tr>\n<tr>\n<td>GCC 15 <code>-O3 -march=native</code></td>\n<td>49.0</td>\n<td>765.3</td>\n<td>225.2</td>\n<td>34.3</td>\n<td>88.3</td>\n<td>123.9</td>\n<td>1.7</td>\n<td>19.9</td>\n<td>72.6</td>\n</tr>\n</tbody>\n</table>\n<h4 id=\"summary_5\">Summary</h4>\n<p>772.marian_r is essentially a 706.stockfish_r NNUE clone. The hotspot is int8_t times uint8_t accumulated to int32_t matrix multiplication, with more integer vector instructions than floating-point. It probably should be expelled from SPEC FP 2026 Rate.</p>\n<h3 id=\"782lbm_r\">782.lbm_r</h3>\n<p>lbm stands for Lattice Boltzmann Method, another fluid dynamics application, still Stencil. Single workload:</p>\n<div class=\"language-shell highlight\"><pre><span></span><code><span id=\"__span-18-1\"><a id=\"__codelineno-18-1\" name=\"__codelineno-18-1\" href=\"#__codelineno-18-1\"></a>lbm_r<span class=\"w\"> </span><span class=\"m\">900</span><span class=\"w\"> </span>reference.dat<span class=\"w\"> </span><span class=\"m\">0</span><span class=\"w\"> </span><span class=\"m\">0</span><span class=\"w\"> </span>200_200_130_ldc.of\n</span></code></pre></div>\n<p>reftime is 573s. Performance comparison:</p>\n<table>\n<thead>\n<tr>\n<th>Compiler + Flags</th>\n<th>Time (s)</th>\n<th>Score</th>\n<th>Improvement over GCC 14 <code>-O3</code> (%)</th>\n<th>Insns (B)</th>\n<th>Load (B)</th>\n<th>Store (B)</th>\n<th>Branch (B)</th>\n<th>FP Scalar (B)</th>\n<th>FP Vector (B)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>GCC 14 <code>-O3</code></td>\n<td>105.8</td>\n<td>5.42</td>\n<td>0</td>\n<td>2232.2</td>\n<td>473.3</td>\n<td>242.4</td>\n<td>14.5</td>\n<td>1108.2</td>\n<td>0.0</td>\n</tr>\n<tr>\n<td>GCC 14 <code>-O3 -ffast-math</code></td>\n<td>95.8</td>\n<td>5.98</td>\n<td>10</td>\n<td>1892.4</td>\n<td>419.2</td>\n<td>192.8</td>\n<td>14.5</td>\n<td>1009.5</td>\n<td>0.0</td>\n</tr>\n<tr>\n<td>GCC 14 <code>-O3 -march=native</code></td>\n<td>131.0</td>\n<td>4.37</td>\n<td>-19</td>\n<td>1669.6</td>\n<td>550.3</td>\n<td>309.8</td>\n<td>14.5</td>\n<td>1228.8</td>\n<td>0.0</td>\n</tr>\n<tr>\n<td>GCC 15 <code>-O3</code></td>\n<td>105.2</td>\n<td>5.45</td>\n<td>0.6</td>\n<td>2218.9</td>\n<td>468.9</td>\n<td>242.4</td>\n<td>14.5</td>\n<td>1108.2</td>\n<td>0.0</td>\n</tr>\n<tr>\n<td>GCC 15 <code>-O3 -march=native</code></td>\n<td>111.0</td>\n<td>5.16</td>\n<td>-5</td>\n<td>1777.3</td>\n<td>509.8</td>\n<td>282.9</td>\n<td>14.5</td>\n<td>1108.2</td>\n<td>0.0</td>\n</tr>\n<tr>\n<td>GCC 16 <code>-O3</code></td>\n<td>105.4</td>\n<td>5.44</td>\n<td>0.4</td>\n<td>2218.9</td>\n<td>468.9</td>\n<td>242.4</td>\n<td>14.5</td>\n<td>1108.2</td>\n<td>0.0</td>\n</tr>\n<tr>\n<td>GCC 16 <code>-O3 -march=native</code></td>\n<td>110.6</td>\n<td>5.18</td>\n<td>-4</td>\n<td>1777.3</td>\n<td>509.8</td>\n<td>282.9</td>\n<td>14.5</td>\n<td>1108.2</td>\n<td>0.0</td>\n</tr>\n</tbody>\n</table>\n<p>The sole hotspot function is <code>LBM_performStreamCollideTRT</code> from <code>src/lbm.c</code>, accounting for 99.35% of time. Its structure is: read from current-round Grid, heavy floating-point computation, write to next-round Grid, with conditional branches in between. Memory access is strided, making vectorization difficult; all generated instructions are SSE scalar. For such scalar-compute-intensive cases, <code>-O3 -ffast-math</code> typically helps by reordering computations and reusing intermediate results.</p>\n<p><code>-O3 -march=native</code> actually regresses performance. GCC 14 regresses worst (-19%); GCC 15/16 regress less but still underperform <code>-O3</code>. Assembly analysis suggests increased stack memory access instructions offset the FMA instruction count reduction benefit (see <a href=\"https://godbolt.org/z/5Ynsjn5o8\">Godbolt</a>). Note that FMA instructions are counted twice in the FP scalar column but only once in total instruction count.</p>\n<h2 id=\"discussion\">Discussion</h2>\n<h3 id=\"compiler-flags-comparison\">Compiler Flags Comparison</h3>\n<p>Overall, compiler flags have significant impact on SPEC FP 2026 Rate performance:</p>\n<ul>\n<li><code>-march=native</code> provides solid improvement for many benchmarks. AVX2 not only widens vectors compared to SSE but also adds many useful instructions that reduce instruction count, plus AVX-VNNI specifically benefits 772.marian_r;</li>\n<li><code>-ffast-math</code> also helps notably, especially since SPEC FP 2026 Rate has substantial floating-point computation. Strictly following source code computation order is often slower than optimized ordering. However, <code>-ffast-math</code> may produce results not conforming to IEEE 754;</li>\n<li><code>-flto</code> and <code>-ljemalloc</code> have minimal effect on most SPEC FP 2026 Rate benchmarks, though they slightly help 748.flightdm_r.</li>\n</ul>\n<p>Other common flags like <code>-static</code> and <code>-fomit-frame-pointer</code> haven't been extensively tested yet.</p>\n<h3 id=\"branch-prediction\">Branch Prediction</h3>\n<p>Only 731.astcenc_r and 737.gmsh_r have notably high MPKI in SPEC FP 2026 Rate; others peak at 767.nest_r's 0.87. 731.astcenc_r's high MPKI is entirely due to GCC 14's poor compilation. Switching to LLVM 22 immediately normalizes it. Hopefully GCC will address this.</p>\n<h2 id=\"conclusion\">Conclusion</h2>\n<p>This article provides in-depth analysis of SPEC CPU 2026 FP Rate workloads, for reference by compiler and processor designers. From a compiler perspective, combining the strengths of both GCC and LLVM can further improve performance. From a processor perspective, optimizing for program bottlenecks can further increase scores.</p>","date_modified":"2026-05-29T00:00:00+00:00","date_published":"2026-05-29T00:00:00+00:00","id":"https://jia.je/software/2026/05/29/spec-cpu-2026-workload-analysis-fp-rate-en/","image":null,"tags":["benchmark","software","spec","speccpu2026"],"title":"SPEC CPU 2026 Workload Analysis (FP Rate)","url":"https://jia.je/software/2026/05/29/spec-cpu-2026-workload-analysis-fp-rate-en/"}],"language":"zh","title":"杰哥的{教学，运维，编程，调板子}小笔记","version":"https://jsonfeed.org/version/1.1"}