<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom">
  <title>Calvin&#39;s Marbles</title>
  
  
  <link href="http://www.calvinneo.com/atom.xml" rel="self"/>
  
  <link href="http://www.calvinneo.com/"/>
  <updated>2026-10-20T05:18:47.907Z</updated>
  <id>http://www.calvinneo.com/</id>
  
  <author>
    <name>Calvin Neo</name>
    
  </author>
  
  <generator uri="https://hexo.io/">Hexo</generator>
  
  <entry>
    <title>Memray attach 故障分析：uprobe 撤销与 UCX 内联 hook 的冲突</title>
    <link href="http://www.calvinneo.com/2026/10/19/memray-ucx-uprobe-investigation/"/>
    <id>http://www.calvinneo.com/2026/10/19/memray-ucx-uprobe-investigation/</id>
    <published>2026-10-18T16:00:00.000Z</published>
    <updated>2026-10-20T05:18:47.907Z</updated>
    
    <content type="html"><![CDATA[<p>Memray attach 到一个运行中的 Python 进程时，在创建辅助线程的过程中触发了 <code>SIGSEGV</code>。沿着调用栈检查，问题落在 libc 的 <code>mmap</code> 入口：首字节是 libc 文件中的原始内容，紧接着的四字节却能解出一条指向 UCX 的跳转位移。</p><p>调查记录中的独立映射实验复现了这个变化。实际使用的 memleak 安装 uprobe 时，把入口首字节从 <code>E9</code> 改成 <code>CC</code>，退出时又恢复成 <code>F3</code>。最终留下的 16 字节与故障进程完全一致。本文围绕这段字节的来源，记录故障指令、UCX hook、内核恢复路径与对照实验之间的关系。<strong>字节损坏机制已经复现，原进程的历史写入过程没有被直接记录。</strong></p><a id="more"></a><h2 id="故障环境与-Memray-的调用路径"><a href="#故障环境与-Memray-的调用路径" class="headerlink" title="故障环境与 Memray 的调用路径"></a>故障环境与 Memray 的调用路径</h2><p>此前的<a href="/2024/08/23/use-ebpf-to-monitor-memory/">使用 eBPF 监控内存分配</a>主要讨论分配统计与 RSS 等指标的关系。这次是在一个包含 Python 和原生库的推理环境中排查内存增长，接入 Memray 时发生了异常，需要先查清辅助线程为什么创建失败。</p><p>以下版本、地址和实验输出来自 2026 年 10 月 19 日的调查记录。目标是容器中的 PID 1，命令行以 <code>/usr/bin/python /usr/local/bin/torchrun --nproc_per_node 8</code> 开头，进程名为 <code>pt_elastic</code>，从 10 月 17 日起运行。这个进程负责启动和管理 worker，是 launcher。本文取证的地址与字节属于这个 launcher，其他 worker 有各自的 PID 和地址空间。</p><table><thead><tr><th>项目</th><th>现场信息</th></tr></thead><tbody><tr><td>架构与内核</td><td>x86-64，<code>5.15.0-94-generic</code></td></tr><tr><td>容器用户空间</td><td>Ubuntu 24.04 noble</td></tr><tr><td>Python</td><td><code>3.12.3</code></td></tr><tr><td>Memray</td><td><code>1.20.0</code></td></tr><tr><td>GDB</td><td><code>15.1-1ubuntu1~24.04.1</code></td></tr><tr><td>glibc 包</td><td><code>libc6 2.39-0ubuntu8.5</code></td></tr><tr><td>UCX 内存事件库</td><td><code>/opt/hpcx/ucx/lib/libucm.so.0.0.0</code>，精确发行版本未取得</td></tr><tr><td>实际成功运行的 memleak</td><td><code>/usr/sbin/memleak</code>，日志与行为对应 libbpf-tools 实现，精确构建版本未取得</td></tr></tbody></table><p>这里容器中的用户空间是 Ubuntu 24.04，使用的宿主机内核是 <code>5.15.0-94-generic</code>。</p><p>Memray 最初只报告：</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">An unexpected error occurred. Run with --verbose to debug the failure.</span><br></pre></td></tr></table></figure><p>补充 GDB 诊断后，相关调用栈如下：</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line">#0  0x00007fc3785a32f0 in mmap64 () from libc.so.6</span><br><span class="line">#1  0x00007fc37851b537 in pthread_create () from libc.so.6</span><br><span class="line">#2  memray_spawn_client (...) at inject.cpp:264</span><br><span class="line">#3  &lt;function called from gdb&gt;</span><br></pre></td></tr></table></figure><p>这条 attach 路径通过 GDB 在目标进程中执行函数，GDB 把这种操作称为 <strong>inferior call</strong>，其中 inferior 就是被调试进程。<a href="https://github.com/bloomberg/memray/blob/v1.20.0/src/memray/_memray/inject.cpp#L256" target="_blank" rel="noopener">Memray 1.20.0 的注入实现</a>在 <code>memray_spawn_client()</code> 中调用 <code>pthread_create()</code>。源码注释说明，attach 时解释器可能正在修改 GC 链表等不可重入的状态，因此创建一个辅助线程，由它取得 GIL（CPython 的全局解释器锁）后再执行 Python 代码。</p><p>这次创建线程需要为线程栈建立映射。现场寄存器中的映射长度是 <code>0x801000</code>：</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">0x801000 = 8 × 1024 × 1024 + 4096 字节</span><br><span class="line">         = 8 MiB + 4 KiB</span><br></pre></td></tr></table></figure><p>这个长度与本次调用中 8 MiB 栈加一页保护空间的分配路径相符。调查记录对精确版本 libc 的离线反汇编还确认，栈中返回地址之前是一条直接调用 <code>mmap</code> 入口的指令。</p><p>发生异常的是已有主线程 LWP 1，它正在执行 GDB 发起的函数调用，辅助线程尚未创建成功。这次到达故障入口的具体路径是 <code>memray_spawn_client → pthread_create → mmap</code>。</p><h2 id="mmap-入口的字节与故障地址"><a href="#mmap-入口的字节与故障地址" class="headerlink" title="mmap 入口的字节与故障地址"></a>mmap 入口的字节与故障地址</h2><h3 id="内存中的入口与-libc-文件不同"><a href="#内存中的入口与-libc-文件不同" class="headerlink" title="内存中的入口与 libc 文件不同"></a>内存中的入口与 libc 文件不同</h3><p>现场停在 <code>mmap64</code> 的第一条指令：</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">0x7fc3785a32f0 &lt;mmap64&gt;: repz mov -0x2(%rbx,%rdi,2),%eax</span><br></pre></td></tr></table></figure><p>为核对这条指令，调查继续读取进程内存中的字节。GDB 会管理软件断点，部分内存读取接口会展示被断点替换之前的内容，因此这里采用调试器退出后的独立读取。</p><p>在 GDB detach 之后，通过 <code>/proc/1/mem</code> 直接读取同一地址，并与目标进程根目录下的 libc 文件比较，得到：</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">memory: f3 8b 44 7b fe f7 c1 ff 0f 00 00 75 33 55 48 89</span><br><span class="line">disk:   f3 0f 1e fa 41 f7 c1 ff 0f 00 00 75 33 55 48 89</span><br></pre></td></tr></table></figure><p>这里选择读取 16 字节，是为了同时覆盖前五字节补丁和紧接着的指令。检查前还核对了 <code>/proc/1/stat</code> 的启动时间字段，避免 PID 被复用后读到另一个进程。</p><p>文件中的 <code>F3 0F 1E FA</code> 是 <code>ENDBR64</code>，用于 x86 控制流保护技术 CET 中的间接分支跟踪。启用间接分支跟踪时，这条指令标记允许到达的间接分支目标。本例需要核对的是它占据的四个字节。后面的 <code>41 F7 C1 ...</code> 则是检查 <code>%r9d</code> 低位的指令。</p><p>比较文件内容还需要把进程虚拟地址换算成文件偏移。现场包含故障地址的映射从 <code>0x7fc3785a3000</code> 开始，对应文件偏移 <code>0x125000</code>，因此：</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line">入口文件偏移 = 映射文件偏移 +（入口虚拟地址 - 映射起始地址）</span><br><span class="line">             = 0x125000 + (0x7fc3785a32f0 - 0x7fc3785a3000)</span><br><span class="line">             = 0x1252f0</span><br></pre></td></tr></table></figure><p>诊断包记录了映射所对应的文件与目标根目录下的 libc 具有相同 inode 和 Build ID。离线取得的 Ubuntu 官方库也匹配这个 Build ID，其文件标识如下：</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">Build ID: 282c2c16e7b6600b0b22ea0c99010d2795752b5f</span><br><span class="line">SHA256:   de259f5276c4a991f78bf87225d6b40e56edbffe0dcbc0ffca36ec7fe30f3f77</span><br></pre></td></tr></table></figure><p>文件身份核对确认了这些字节属于同一构建的 libc，detach 后的直接读取确认了错误字节仍留在进程内存中。</p><h3 id="错误指令解释了本次-SIGSEGV"><a href="#错误指令解释了本次-SIGSEGV" class="headerlink" title="错误指令解释了本次 SIGSEGV"></a>错误指令解释了本次 SIGSEGV</h3><p>现场寄存器与信号信息为：</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line">rbx     = 0xfffffffffffff000  # 按有符号数解释为 -4096</span><br><span class="line">rdi     = 0</span><br><span class="line">si_addr = 0xffffffffffffeffe  # 按有符号数解释为 -4098</span><br></pre></td></tr></table></figure><p>按这条 <code>mov</code> 的寻址方式，读取地址是：</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">rbx + rdi × 2 - 2 = -4096 + 0 × 2 - 2 = -4098</span><br></pre></td></tr></table></figure><p>结果与信号中的 <code>si_addr</code> 完全一致。这使得故障栈、实际入口字节、寄存器与非法访问地址相互对应：本次 <code>SIGSEGV</code> 就发生在错误入口的第一次内存读取处。</p><h2 id="残留位移与-UCX-内联-hook"><a href="#残留位移与-UCX-内联-hook" class="headerlink" title="残留位移与 UCX 内联 hook"></a>残留位移与 UCX 内联 hook</h2><p>内存中的前五字节是 <code>F3 8B 44 7B FE</code>。如果把首字节暂时按 <code>E9</code> 解释，后面的四字节恰好能构成一条 x86-64 相对跳转。</p><p><code>E9 rel32</code> 总共占五字节，<code>E9</code> 是操作码，<code>rel32</code> 是小端编码的有符号 32 位位移。跳转基准是这条指令结束后的地址，因此可以离线计算：</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line">候选指令：E9 8B 44 7B FE</span><br><span class="line">位移：    0xFE7B448B - 2^32 = -25,475,957</span><br><span class="line">目标：    0x7fc3785a32f0 + 5 - 25,475,957</span><br><span class="line">        = 0x7fc376d57780</span><br></pre></td></tr></table></figure><p>候选目标位于已经加载的 <code>libucm.so.0.0.0</code> 中。根据现场映射换算到库内，位置是 <code>0xb780</code>，恰好对应：</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line">000000000000b780 &lt;ucm_override_mmap&gt;:</span><br><span class="line">    b780: f3 0f 1e fa    endbr64</span><br><span class="line">    b784: 41 57          push %r15</span><br><span class="line">    ...</span><br></pre></td></tr></table></figure><p>这四字节位移恰好指向 <code>ucm_override_mmap</code> 的入口。整个计算使用已经取得的地址与字节，在离线条件下完成。</p><h3 id="libucm-的内存事件机制"><a href="#libucm-的内存事件机制" class="headerlink" title="libucm 的内存事件机制"></a>libucm 的内存事件机制</h3><p>UCX 是面向高性能通信的软件框架，<code>libucm</code> 是其中负责内存事件的组件。<strong>内联 hook</strong> 指直接改写已有函数的入口，把调用转到替代实现。在这个例子中，libc 的 <code>mmap</code> 入口被改成跳转，原本进入 libc 的调用就会先到达 <code>ucm_override_mmap</code>。</p><p>UCX 需要知道映射何时建立、释放或改变。例如，在 RDMA 场景中，注册一段内存需要向通信设备登记地址范围与访问权限。注册缓存保存已经完成注册的区域，后续操作可以复用它们。应用释放一段映射后，同一虚拟地址可以映射到另一组物理页，因此覆盖这段地址的旧缓存项需要失效。<code>libucm</code> 提供 <code>mmap</code>、<code>munmap</code> 等内存事件，供注册缓存处理这些变化。</p><p>在 <a href="https://github.com/openucx/ucx/blob/v1.18.0/src/ucs/memory/rcache.c#L618" target="_blank" rel="noopener">UCX v1.18.0 的注册缓存实现</a>中，<code>ucs_rcache_unmapped_callback()</code> 收到 <code>UCM_EVENT_VM_UNMAPPED</code> 后，从事件中取得地址和长度，算出待失效范围。随后按锁与配置条件立即处理相交缓存项，或把这个范围放入失效队列。这就是内存事件与注册缓存之间的具体连接。</p><p>在 <a href="https://github.com/openucx/ucx/blob/v1.18.0/src/ucm/mmap/install.c#L61" target="_blank" rel="noopener">UCX v1.18.0 的安装代码</a>中，内存事件表通过 <code>UCM_MMAP_RELOC_ENTRY(mmap)</code> 将 <code>mmap</code> 与 <code>ucm_override_mmap</code> 对应起来。在称为 <strong>bistro</strong> 的内联改写模式下，安装逻辑取得原函数地址，然后调用 <code>ucm_bistro_patch()</code>。<a href="https://github.com/openucx/ucx/blob/v1.18.0/src/ucm/bistro/bistro_x86_64.c#L319" target="_blank" rel="noopener">x86-64 实现</a>在位移允许且未强制远跳转时，使用上述 <code>E9 rel32</code> 补丁。</p><p>实际建立映射仍然由内核完成。bistro 模式的<a href="https://github.com/openucx/ucx/blob/v1.18.0/src/ucm/util/replace.h#L100" target="_blank" rel="noopener">原始操作路径</a>可以直接发起系统调用，避免重新进入刚刚改写的 libc 入口。</p><p>安装代码用 <code>installed_events</code> 记录已经安装的事件，遍历事件表时会跳过对应项。跳转写入入口后，后续调用直接执行这条跳转。本次分析的起点就是探针安装前已经存在的五字节跳转。</p><blockquote><p>现场没有取得 UCX 的精确发行版本，v1.18.0 用来核对实现路径。对现场库的判断依据是残留位移、进程映射以及 <code>ucm_override_mmap</code> 的符号位置。调查记录还列出了已加载的 PyTorch、Open MPI、UCC 等库，具体业务请求的通信调用栈未被采集。</p></blockquote><h2 id="uprobe-保存与恢复的原始指令"><a href="#uprobe-保存与恢复的原始指令" class="headerlink" title="uprobe 保存与恢复的原始指令"></a>uprobe 保存与恢复的原始指令</h2><p>接下来的问题是，谁会保留跳转的四字节位移，却把 <code>E9</code> 变回文件中的 <code>F3</code>。先前运行过的 memleak 是一条需要核查的路径。</p><p>memleak 的用户态分配追踪在 <code>malloc</code>、<code>mmap</code> 等函数进入和返回时采集分配信息，再与释放事件关联。这里使用的 <strong>uprobe</strong> 是 Linux 的用户态动态探针机制，探测位置以文件 inode 和文件偏移标识，再应用到目标进程的相应映射。eBPF 程序负责探针命中后的采集逻辑，代码位置上的探针由内核安装。</p><p>在本次 x86-64 路径中，内核将探测位置的首字节改成 <code>CC</code>，即一字节的 <code>INT3</code> 软件断点。执行到这里时，CPU 触发断点异常，内核识别 uprobe，调用关联处理逻辑，再执行或模拟被替换的原指令。需要异地执行时会使用 <strong>XOL（execute out of line）</strong> 指令区，即在独立位置执行保存的指令，然后继续原执行流。</p><p>这里选择 <code>mmap</code> 的入口作为探测位置。原来的 <code>ENDBR64</code> 占四字节，UCX 跳转占五字节，<code>INT3</code> 占一字节。安装探针时只需用 <code>CC</code> 覆盖这条入口指令的第一个字节。</p><h3 id="保存值来自文件页缓存"><a href="#保存值来自文件页缓存" class="headerlink" title="保存值来自文件页缓存"></a>保存值来自文件页缓存</h3><p>在上游 Linux v5.15 的 <a href="https://github.com/torvalds/linux/blob/v5.15/kernel/events/uprobes.c#L790" target="_blank" rel="noopener"><code>copy_insn()</code></a> 中，读取来源是：</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line"><span class="class"><span class="keyword">struct</span> <span class="title">address_space</span> *<span class="title">mapping</span> = <span class="title">uprobe</span>-&gt;<span class="title">inode</span>-&gt;<span class="title">i_mapping</span>;</span></span><br><span class="line"><span class="keyword">loff_t</span> offs = uprobe-&gt;offset;</span><br><span class="line"><span class="keyword">void</span> *insn = &amp;uprobe-&gt;arch.insn;</span><br></pre></td></tr></table></figure><p>它通过 <code>__copy_insn()</code>，从文件页缓存读取对应偏移的指令。对于这里的普通文件，该函数使用 <code>read_mapping_page()</code> 取得页面，然后把内容复制到 <code>uprobe-&gt;arch.insn</code>。</p><p>这份保存值与进程私有代码页中当前的指令可以不同。UCX 改写的是进程中的映射，libc 文件仍以 <code>F3 0F 1E FA</code> 开头，所以内核保存的原指令也从 <code>F3</code> 开始。</p><p><strong>内核在准备探针时保存文件页缓存中的指令，撤销时使用这份保存值。</strong> 文件页已经在缓存中时，读取直接使用该页。</p><h3 id="写入保留了当前页面的其他字节"><a href="#写入保留了当前页面的其他字节" class="headerlink" title="写入保留了当前页面的其他字节"></a>写入保留了当前页面的其他字节</h3><p>实际修改进程代码走的是 <a href="https://github.com/torvalds/linux/blob/v5.15/kernel/events/uprobes.c#L464" target="_blank" rel="noopener"><code>uprobe_write_opcode()</code></a>。其中两个连续操作说明了新页面从哪里来，以及改多少字节：</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">copy_highpage(new_page, old_page);</span><br><span class="line">copy_to_page(new_page, vaddr, &amp;opcode, UPROBE_SWBP_INSN_SIZE);</span><br></pre></td></tr></table></figure><p>先复制进程当前的页面，再只替换断点覆盖的部分。<a href="https://github.com/torvalds/linux/blob/v5.15/arch/x86/include/asm/uprobes.h#L20" target="_blank" rel="noopener">x86 定义</a>为：</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line"><span class="meta">#<span class="meta-keyword">define</span> UPROBE_SWBP_INSN       0xcc</span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">define</span> UPROBE_SWBP_INSN_SIZE     1</span></span><br></pre></td></tr></table></figure><p>安装时写入 <code>CC</code>。撤销时，<a href="https://github.com/torvalds/linux/blob/v5.15/kernel/events/uprobes.c#L589" target="_blank" rel="noopener"><code>set_orig_insn()</code></a>传入保存的原指令起始字节，通过同一写入路径恢复。于是，读取“原始内容”的来源是文件页缓存，保留其余字节的来源却是进程当前页面。</p><p>将这两个来源放到现场的五字节上，得到：</p><table><thead><tr><th>状态</th><th>libc 文件中的入口</th><th>进程内存中的入口</th></tr></thead><tbody><tr><td>未改写</td><td><code>F3 0F 1E FA 41</code></td><td><code>F3 0F 1E FA 41</code></td></tr><tr><td>UCX 安装跳转后</td><td><code>F3 0F 1E FA 41</code></td><td><code>E9 8B 44 7B FE</code></td></tr><tr><td>uprobe 安装后</td><td><code>F3 0F 1E FA 41</code></td><td><code>CC 8B 44 7B FE</code></td></tr><tr><td>uprobe 撤销后</td><td><code>F3 0F 1E FA 41</code></td><td><code>F3 8B 44 7B FE</code></td></tr></tbody></table><p>内核保存的是 <code>F3</code>，安装时覆盖的却是 <code>E9</code>。撤销只恢复首字节，后面仍是 UCX 跳转的位移，最终组成了一条混合指令。</p><p>撤销代码还会比较恢复后的页面与文件页缓存是否完全一致。如果一致，可以让映射回到文件页。本例保留了四字节跳转位移，整页相等的条件不成立，进程继续使用包含这些字节的私有页面。</p><p>这几次写入可以严格按顺序发生：UCX 安装跳转，memleak 安装探针，再撤销探针。每一步读取和写入的内容由上表确定。即使目标始终没有执行过这个入口，完成安装与撤销也会留下 <code>F3 8B 44 7B FE</code>。</p><blockquote><p><a href="https://github.com/torvalds/linux/blob/v5.15/kernel/events/uprobes.c#L258" target="_blank" rel="noopener"><code>verify_opcode()</code></a>在撤销时检查当前位置是否仍是软件断点。当前位置已经被改成其他字节时，它会返回并跳过恢复。本例撤销前的字节为 <code>CC</code>，满足继续恢复的条件。上述源码来自上游 v5.15，现场 Ubuntu <code>5.15.0-94</code> 的完整补丁集尚未核对，后面的实验用于验证现场内核实际写入了什么。</p></blockquote><h2 id="memleak-的实现与运行记录"><a href="#memleak-的实现与运行记录" class="headerlink" title="memleak 的实现与运行记录"></a>memleak 的实现与运行记录</h2><p>调查记录中出现了两个 memleak 命令，它们的实现和运行结果不同。</p><table><thead><tr><th>命令</th><th>实现</th><th>记录到的结果</th></tr></thead><tbody><tr><td><code>/usr/sbin/memleak-bpfcc</code></td><td>BCC Python 脚本</td><td>缺少 kernel headers，在编译 BPF 模块时失败</td></tr><tr><td><code>/usr/sbin/memleak -p 1 5 3</code></td><td>日志与行为对应 libbpf-tools 实现</td><td>正常输出过周期统计</td></tr></tbody></table><p>第一条命令的错误停在：</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line">Unable to find kernel headers.</span><br><span class="line">...</span><br><span class="line">bpf = BPF(text=bpf_source)</span><br><span class="line">Exception: Failed to compile BPF module &lt;text&gt;</span><br></pre></td></tr></table></figure><p><a href="https://github.com/iovisor/bcc/blob/v0.29.1/tools/memleak.py#L464" target="_blank" rel="noopener">BCC v0.29.1 的 Python 实现</a>先执行 <code>BPF(text=bpf_source)</code>，成功后才依次调用 <code>attach_probes()</code>。因此，记录中的这次失败发生在 <code>mmap</code> 探针安装之前。</p><p>第二条命令中的 <code>-p 1</code> 指向目标进程，<code>5</code> 是报告间隔秒数，<code>3</code> 是报告次数。这是当时的操作记录。随后用于对照实验的也是这个 <code>/usr/sbin/memleak</code>。</p><p>两种实现对安装失败的处理有一处与本次调查直接相关的差异。Python 版调用 <code>attach_probes(&quot;mmap&quot;, can_fail=True)</code>，允许该探针安装失败后继续运行。<a href="https://github.com/iovisor/bcc/blob/v0.29.1/libbpf-tools/memleak.c#L1029" target="_blank" rel="noopener">libbpf-tools 的对应代码</a>则为 <code>mmap</code> 入口和返回探针使用检查错误的宏：</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">ATTACH_UPROBE_CHECKED(skel, mmap, mmap_enter);</span><br><span class="line">ATTACH_URETPROBE_CHECKED(skel, mmap, mmap_exit);</span><br></pre></td></tr></table></figure><p>在所核对的实现中，任一安装失败都会离开 <code>attach_uprobes()</code>，主程序进入清理流程。成功后才进入周期报告循环。退出时，程序释放持有的探针连接，内核据此移除相应探针。因此，正常输出周期统计提供了探针安装已通过的线索。</p><p>这里引用 v0.29.1，是因为日志文本、探针逻辑，以及下一节的路径截断行为与现场相符。实际二进制的包归属、版本和哈希尚未取得，本文保留这个版本信息缺口。</p><h2 id="独立映射上的对照实验"><a href="#独立映射上的对照实验" class="headerlink" title="独立映射上的对照实验"></a>独立映射上的对照实验</h2><p>实验要测量的是三个时刻的入口字节：安装之前、探针存在期间、撤销之后。为此，可以只映射 libc 副本并观察代码页，把实际函数调用留在实验之外。</p><p>实验脚本可下载：<a href="/asset/memray-ucx-uprobe/verify-uprobe-restore.py">verify-uprobe-restore.py</a>。它在原容器中运行，使用现场的 libc 和 <code>/usr/sbin/memleak</code>，以脚本自身的 PID 为探测目标。</p><h3 id="文件与映射的安排"><a href="#文件与映射的安排" class="headerlink" title="文件与映射的安排"></a>文件与映射的安排</h3><p>脚本先检查 libc 文件的 SHA256，再检查文件偏移 <code>0x1252f0</code> 处的 16 字节是否与现场原始入口相同。这个偏移由前面的映射换算得到，哈希检查将它限定在已核对的 libc 构建上。</p><p>接着，脚本普通复制一份 libc，并检查副本与源文件的设备号、inode 组合不同。因为 uprobe 用 inode 和文件偏移定位探测位置，副本的独立 inode 能让本次安装作用于副本对应的映射。</p><p>同一个副本建立两份 <code>MAP_PRIVATE</code> 映射：</p><table><thead><tr><th>映射</th><th>初始入口</th><th>用途</th></tr></thead><tbody><tr><td>control</td><td><code>F3 0F 1E FA 41 ...</code></td><td>检查原始入口能否在撤销后恢复</td></tr><tr><td>patched</td><td><code>E9 8B 44 7B FE ...</code></td><td>检查已有跳转在撤销后留下哪些字节</td></tr></tbody></table><p>实验组起初以可读、可写权限映射，写入五字节补丁后，调用 <code>mprotect()</code> 改成只读、可执行，即 <code>RX</code>。这是实验成立的一个具体条件：上游 v5.15 的 <a href="https://github.com/torvalds/linux/blob/v5.15/kernel/events/uprobes.c#L121" target="_blank" rel="noopener"><code>valid_vma()</code></a>在安装探针时排除带 <code>VM_WRITE</code> 的映射。脚本会检查 <code>/proc/self/maps</code>，确认两份映射的权限均为 <code>r-xp</code> 后再启动 memleak。</p><p>探针通过 <code>-p</code> 指定脚本 PID，通过 <code>-O</code> 指定 libc 副本。报告间隔设为一秒，共报告两次，以留出观察 <code>CC</code> 的时间窗口。脚本在 memleak 运行前、运行期间和退出后读取两份映射，并在结束时检查磁盘副本的内容。</p><p>实验组中的跳转位移原样取自现场。由于映射地址已经改变，这份位移在实验进程中没有对应的 UCX 调用目标。脚本仅将映射中的字节作为数据读取，全程没有调用其中的代码。</p><h3 id="首次运行中的对象路径截断"><a href="#首次运行中的对象路径截断" class="headerlink" title="首次运行中的对象路径截断"></a>首次运行中的对象路径截断</h3><p>首次运行没有观察到字节变化，结果为 <code>INCONCLUSIVE</code>。memleak 日志给出了安装失败的位置：</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line">libbpf: elf: failed to open /tmp/uprobe-restore-0b5_rgb8/li: No such file or directory</span><br><span class="line">no program attached for malloc_enter: No such file or directory</span><br><span class="line">failed to attach uprobes</span><br></pre></td></tr></table></figure><p>传入的完整路径为：</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">/tmp/uprobe-restore-0b5_rgb8/libc-copy.so</span><br></pre></td></tr></table></figure><p>这个路径包含 41 个 ASCII 字节，日志中的路径只剩下前 31 字节。<a href="https://github.com/iovisor/bcc/blob/v0.29.1/libbpf-tools/memleak.c#L43" target="_blank" rel="noopener">libbpf-tools 的对象路径字段</a>定义为 <code>char object[32]</code>，处理 <code>-O</code> 时使用：</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line"><span class="built_in">strncpy</span>(env.object, arg, <span class="keyword">sizeof</span>(env.object) - <span class="number">1</span>);</span><br></pre></td></tr></table></figure><p>最多复制 31 字节，最后一个位置留给 <code>NUL</code>。被截断的文件路径不存在，因此 memleak 在第一个 <code>malloc_enter</code> 探针处退出。这轮运行尚未到达 <code>mmap</code> 探针的安装步骤。</p><p>随后把临时目录前缀缩短，得到 <code>/tmp/ur-xxxxxxxx/c.so</code> 这样的路径。其中随机目录名部分为 8 个字符，整个路径共 21 字节。脚本同时加入长度检查，再进行下一轮实验。</p><h3 id="安装与撤销期间的实测字节"><a href="#安装与撤销期间的实测字节" class="headerlink" title="安装与撤销期间的实测字节"></a>安装与撤销期间的实测字节</h3><p>调查记录中，在原容器执行：</p><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">python3 verify-uprobe-restore.py /usr/sbin/memleak</span><br></pre></td></tr></table></figure><p>输出如下，PID、临时路径、设备号和 inode 均为这次运行的实际值。<code>#</code> 开头的注释为本文补充：</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br></pre></td><td class="code"><pre><span class="line"># 脚本读取原 libc 文件并计算 SHA256，随后校验它是否为固定偏移所对应的构建。</span><br><span class="line">libc SHA256: de259f5276c4a991f78bf87225d6b40e56edbffe0dcbc0ffca36ec7fe30f3f77</span><br><span class="line"># 复制并校验 libc 副本后，打印保存副本、映射信息和实验日志的临时目录。</span><br><span class="line">Evidence directory: /tmp/ur-gfv8n1n1</span><br><span class="line"># 对源文件和副本分别调用 stat，打印 (设备号, inode)；两组值不同，确认副本是独立文件。</span><br><span class="line">Source/copy device+inode: (2097292, 56099800) (2051, 2398963)</span><br><span class="line"># 两份映射准备完成，打印待执行命令。-p 指定脚本 PID，-O 指定副本，1 2 表示每秒报告一次、共两次。</span><br><span class="line">Command: /usr/sbin/memleak -p 83885 -O /tmp/ur-gfv8n1n1/c.so 1 2</span><br><span class="line"># memleak 尚未启动，读取对照组入口，得到 libc 文件中的原始字节。</span><br><span class="line">before control: f3 0f 1e fa 41 f7 c1 ff 0f 00 00 75 33 55 48 89</span><br><span class="line"># memleak 尚未启动，读取实验组入口，前五字节是脚本预先写入的 E9 跳转补丁。</span><br><span class="line">before patched: e9 8b 44 7b fe f7 c1 ff 0f 00 00 75 33 55 48 89</span><br><span class="line"># memleak 已安装探针，轮询读到对照组首字节由内核从 F3 替换为 CC，其余字节保持原样。</span><br><span class="line">during control: cc 0f 1e fa 41 f7 c1 ff 0f 00 00 75 33 55 48 89</span><br><span class="line"># 同一轮读取实验组：内核将首字节 E9 替换为 CC，后四字节仍是跳转位移。</span><br><span class="line">during patched: cc 8b 44 7b fe f7 c1 ff 0f 00 00 75 33 55 48 89</span><br><span class="line"># memleak 退出清理时撤销探针，内核将对照组的 CC 恢复为文件原字节 F3。</span><br><span class="line"># during 表示仍在轮询循环中采集；本轮循环开始时，脚本尚未确认子进程退出。</span><br><span class="line">during control: f3 0f 1e fa 41 f7 c1 ff 0f 00 00 75 33 55 48 89</span><br><span class="line"># 同一轮读取实验组：内核也写回文件原字节 F3，保留了跳转位移，形成损坏的入口。</span><br><span class="line">during patched: f3 8b 44 7b fe f7 c1 ff 0f 00 00 75 33 55 48 89</span><br><span class="line"># 确认 memleak 已退出后，再次读取对照组，16 字节与原 libc 入口一致。</span><br><span class="line">after  control: f3 0f 1e fa 41 f7 c1 ff 0f 00 00 75 33 55 48 89</span><br><span class="line"># 退出后再次读取实验组，F3 加四字节跳转位移仍然存在，16 字节与故障进程中的内容一致。</span><br><span class="line">after  patched: f3 8b 44 7b fe f7 c1 ff 0f 00 00 75 33 55 48 89</span><br><span class="line"># 脚本检查：捕获到实验组的 CC、无超时且退出码为 0、磁盘副本未变，</span><br><span class="line"># 对照组恢复原字节、实验组留下预期损坏字节。全部满足，输出 REPRODUCED。</span><br><span class="line">Result: REPRODUCED</span><br></pre></td></tr></table></figure><p>对照组完成了 <code>F3 → CC → F3</code>。实验组完成了 <code>E9 → CC → F3</code>，后四字节一直是 <code>8B 44 7B FE</code>。最终实验组的 16 字节与 PID 1 中观察到的内容相同。</p><p>脚本要求以下条件同时成立，才输出 <code>REPRODUCED</code>：观察到实验组入口为 <code>CC</code>，memleak 在超时前以状态码 0 退出，磁盘副本保持原样，对照组恢复原始 16 字节，实验组得到准确的损坏字节。这样，现场内核与实际工具怎样安装和撤销探针，就有了直接的字节观测。</p><p>两份映射中都没有执行过代码，这次实验仍然得到了损坏入口。形成这些字节所需的操作已经缩小到：在已有五字节跳转的映射上安装探针，再撤销探针。</p><h2 id="原进程故障与实验结果的对应"><a href="#原进程故障与实验结果的对应" class="headerlink" title="原进程故障与实验结果的对应"></a>原进程故障与实验结果的对应</h2><p>将源码与观测结果放在一起，原进程最符合现有证据的故障过程如下：</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br></pre></td><td class="code"><pre><span class="line">UCX 将 mmap 入口改为 E9 8B 44 7B FE</span><br><span class="line">    ↓</span><br><span class="line">memleak 安装 uprobe，入口变为 CC 8B 44 7B FE</span><br><span class="line">    ↓</span><br><span class="line">memleak 退出，内核恢复文件原指令的首字节 F3</span><br><span class="line">    ↓</span><br><span class="line">入口留下 F3 8B 44 7B FE</span><br><span class="line">    ↓</span><br><span class="line">Memray 通过 GDB 调用 memray_spawn_client</span><br><span class="line">    ↓</span><br><span class="line">pthread_create 为线程栈调用 mmap</span><br><span class="line">    ↓</span><br><span class="line">错误的 mov 读取 0xffffffffffffeffe，触发 SIGSEGV</span><br></pre></td></tr></table></figure><p>每个判断对应的证据可以分别列出：</p><table><thead><tr><th>判断</th><th>依据</th></tr></thead><tbody><tr><td>故障发生在错误入口的内存读取处</td><td>指令的有效地址计算与 <code>si_addr</code> 相同</td></tr><tr><td>入口中四字节位移指向 UCX hook</td><td><code>E9 rel32</code> 的目标地址与现场 <code>ucm_override_mmap</code> 符号重合</td></tr><tr><td>实际 memleak 能留下这些损坏字节</td><td>独立映射实验记录了 <code>E9 → CC → F3</code>，最终 16 字节匹配</td></tr><tr><td>业务 PID 上曾成功运行过 memleak</td><td>操作记录与周期统计输出</td></tr><tr><td>该次运行就是原进程入口损坏的写入来源</td><td>根据以上事实作出的历史归因，缺少原进程改写前的快照与写入瞬间记录</td></tr></tbody></table><p>实验直接验证了安装、撤销与字节变化之间的关系。原进程的历史归因还需要把那次成功运行的 memleak 与具体写入时刻对应起来，现有材料缺少第一次 Memray attach 之前的入口快照，也没有针对该地址的历史写入审计。因此，本文将它保留为最符合现有证据的解释。</p><p>GDB 是调查中检查过的另一条写入路径。<a href="https://github.com/bloomberg/memray/blob/v1.20.0/src/memray/commands/_attach.gdb" target="_blank" rel="noopener">Memray 1.20.0 的 attach 脚本</a>在 <code>malloc</code>、<code>calloc</code>、Python 分配函数等位置设置断点，命中后删除这些断点，再加载注入库并调用 <code>memray_spawn_client()</code>。脚本没有在 <code>mmap</code> 入口设置断点，已有日志也未记录 GDB 在该地址恢复 <code>F3</code>。对 memleak 的判断则有独立映射中相同字节变化的直接支持。</p><p>本次实验覆盖了上述流程中的探针安装和撤销步骤。真实 UCX 初始化、业务进程中的历史执行顺序，以及从初始化一直运行到 Memray 触发异常的完整复现，仍属于尚未完成的验证。</p><h2 id="调用与调试状态补充"><a href="#调用与调试状态补充" class="headerlink" title="调用与调试状态补充"></a>调用与调试状态补充</h2><h3 id="launcher-的后续执行路径"><a href="#launcher-的后续执行路径" class="headerlink" title="launcher 的后续执行路径"></a>launcher 的后续执行路径</h3><p>损坏字节位于 launcher 的地址空间。已有线程可以继续等待，或执行不经过该入口的代码。worker 位于其他进程，它们的执行状态需要分别检查。调查前后 PID 和启动时间没有变化，说明这段观察期间未发现对应进程重启。</p><p>还需要按实际调用地址区分映射路径。直接发起 <code>mmap</code> 系统调用的代码会从自己的系统调用指令进入内核，复用已有内存的分配也可以跳过这次映射。现场 libc 中的 <code>mmap</code>、<code>mmap64</code>、<code>__mmap</code> 则是同地址别名，通过这些符号进入时都会执行同一段字节。</p><h3 id="GDB-对-inferior-call-信号的处理"><a href="#GDB-对-inferior-call-信号的处理" class="headerlink" title="GDB 对 inferior call 信号的处理"></a>GDB 对 inferior call 信号的处理</h3><p>本次 attach 脚本设置了 <code>unwindonsignal</code>。在 inferior call 收到 <code>SIGSEGV</code> 后，GDB 恢复调用前的上下文，然后 detach。它恢复的是被调试调用的执行上下文，函数执行期间已经发生的内存写入、库加载，以及其他线程的动作会留在进程中。</p><p>现场进程在这次调试操作后继续存活，与上述信号处理过程相符。通常未被处理的 <code>SIGSEGV</code> 会终止整个进程，因此用进程内新建线程执行同一错误入口，仍然会影响整个进程。</p><h3 id="探针存在期间的执行"><a href="#探针存在期间的执行" class="headerlink" title="探针存在期间的执行"></a>探针存在期间的执行</h3><p>本次实验将映射用于字节读取，探针没有被命中。由此得到的直接观察覆盖安装与撤销期间的字节变化。探针存在期间，内核执行或模拟保存指令的行为，需要另设执行实验验证。</p><p>这里保存的指令来自文件，进程原本准备执行的指令来自 UCX 补丁，两者已经不同。检查这一组合的兼容性时，还需要观察命中探针后是否按预期进入 <code>ucm_override_mmap</code>，以及后续参数和返回值是否正确。</p><h2 id="处置与后续验证"><a href="#处置与后续验证" class="headerlink" title="处置与后续验证"></a>处置与后续验证</h2><p>后续选择 profiling 工具时，可以具体检查它如何接入目标：是否改写用户态函数入口、是否向目标注入代码、是否在目标中创建线程。本次 Memray 的调用栈确认了它会创建线程，memleak 的对照实验确认了它会通过内核改写入口。对同一版本组合，还应检查两个工具是否覆盖同一段代码，以及撤销探针后原有跳转的五个字节是否完整。</p><h2 id="复现脚本补充"><a href="#复现脚本补充" class="headerlink" title="复现脚本补充"></a>复现脚本补充</h2><p>下载<a href="/asset/memray-ucx-uprobe/verify-uprobe-restore.py">完整实验脚本</a>后，显式指定现场实际使用的 memleak 运行：</p><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">python3 verify-uprobe-restore.py /usr/sbin/memleak</span><br></pre></td></tr></table></figure><p>原脚本省略命令行参数时会查找 <code>memleak-bpfcc</code>。复现实测组合时，按上面的命令显式传入 <code>/usr/sbin/memleak</code>。</p><p>脚本限定 Linux x86-64，并在使用固定偏移前校验 libc 哈希。其他 libc 构建需要重新解析符号与文件偏移，再相应修改校验值。运行环境需要已经具备加载和附着用户态 BPF 探针的条件。</p><p>脚本每 20 毫秒读取一次入口字节，在一秒报告间隔内多次观察探针状态。轮询以 60 秒为期限，超过期限后进入终止测试子进程的流程，依次尝试 <code>SIGINT</code>、<code>SIGTERM</code>、<code>SIGKILL</code>，每次最多等待 5 秒。这些数值都是用于控制实验时长与观察频率的参数。轮询未捕获到 <code>CC</code> 时，脚本会输出 <code>INCONCLUSIVE</code>，此时需要结合日志确认探针是否安装，以及观察窗口是否覆盖了它存在的时间。</p><p>输出目录保留 <code>maps.txt</code>、<code>memleak.log</code>、<code>result.json</code> 与 libc 副本。<code>result.json</code> 记录内核版本、目标 PID、设备号与 inode、实际命令、观测字节和退出状态，便于与下一次运行比较。</p><h2 id="参考资料"><a href="#参考资料" class="headerlink" title="参考资料"></a>参考资料</h2><ul><li>Memray 1.20.0：<a href="https://github.com/bloomberg/memray/blob/v1.20.0/src/memray/commands/_attach.gdb" target="_blank" rel="noopener">GDB attach 脚本</a>、<a href="https://github.com/bloomberg/memray/blob/v1.20.0/src/memray/_memray/inject.cpp#L256" target="_blank" rel="noopener">辅助线程注入代码</a>。</li><li>UCX v1.18.0：<a href="https://github.com/openucx/ucx/blob/v1.18.0/src/ucm/mmap/install.c#L61" target="_blank" rel="noopener">内存事件与 mmap hook 安装</a>、<a href="https://github.com/openucx/ucx/blob/v1.18.0/src/ucm/bistro/bistro_x86_64.c#L319" target="_blank" rel="noopener">x86-64 跳转补丁</a>、<a href="https://github.com/openucx/ucx/blob/v1.18.0/src/ucm/util/replace.h#L100" target="_blank" rel="noopener">bistro 模式的系统调用路径</a>、<a href="https://github.com/openucx/ucx/blob/v1.18.0/src/ucs/memory/rcache.c#L618" target="_blank" rel="noopener">注册缓存的映射释放回调</a>。</li><li>Linux v5.15：<a href="https://github.com/torvalds/linux/blob/v5.15/kernel/events/uprobes.c#L790" target="_blank" rel="noopener">原指令读取</a>、<a href="https://github.com/torvalds/linux/blob/v5.15/kernel/events/uprobes.c#L464" target="_blank" rel="noopener">进程页改写</a>、<a href="https://github.com/torvalds/linux/blob/v5.15/kernel/events/uprobes.c#L589" target="_blank" rel="noopener">恢复入口</a>、<a href="https://github.com/torvalds/linux/blob/v5.15/kernel/events/uprobes.c#L258" target="_blank" rel="noopener">撤销前检查</a>、<a href="https://github.com/torvalds/linux/blob/v5.15/kernel/events/uprobes.c#L121" target="_blank" rel="noopener">映射条件</a>、<a href="https://github.com/torvalds/linux/blob/v5.15/arch/x86/include/asm/uprobes.h#L20" target="_blank" rel="noopener">x86 断点定义</a>。</li><li>BCC v0.29.1：<a href="https://github.com/iovisor/bcc/blob/v0.29.1/tools/memleak.py#L464" target="_blank" rel="noopener">Python memleak</a>、libbpf-tools 的<a href="https://github.com/iovisor/bcc/blob/v0.29.1/libbpf-tools/memleak.c#L1029" target="_blank" rel="noopener">探针安装</a>与<a href="https://github.com/iovisor/bcc/blob/v0.29.1/libbpf-tools/memleak.c#L43" target="_blank" rel="noopener">对象路径字段</a>。</li><li><a href="https://launchpad.net/ubuntu/+archive/primary/+files/libc6_2.39-0ubuntu8.5_amd64.deb" target="_blank" rel="noopener">Ubuntu libc6 2.39-0ubuntu8.5 amd64 官方包</a>，调查中用于核对现场 Build ID、符号和指令。</li></ul>]]></content>
    
    
    <summary type="html">&lt;p&gt;Memray attach 到一个运行中的 Python 进程时，在创建辅助线程的过程中触发了 &lt;code&gt;SIGSEGV&lt;/code&gt;。沿着调用栈检查，问题落在 libc 的 &lt;code&gt;mmap&lt;/code&gt; 入口：首字节是 libc 文件中的原始内容，紧接着的四字节却能解出一条指向 UCX 的跳转位移。&lt;/p&gt;
&lt;p&gt;调查记录中的独立映射实验复现了这个变化。实际使用的 memleak 安装 uprobe 时，把入口首字节从 &lt;code&gt;E9&lt;/code&gt; 改成 &lt;code&gt;CC&lt;/code&gt;，退出时又恢复成 &lt;code&gt;F3&lt;/code&gt;。最终留下的 16 字节与故障进程完全一致。本文围绕这段字节的来源，记录故障指令、UCX hook、内核恢复路径与对照实验之间的关系。&lt;strong&gt;字节损坏机制已经复现，原进程的历史写入过程没有被直接记录。&lt;/strong&gt;&lt;/p&gt;</summary>
    
    
    
    
    <category term="Linux" scheme="http://www.calvinneo.com/tags/Linux/"/>
    
    <category term="内存管理" scheme="http://www.calvinneo.com/tags/内存管理/"/>
    
    <category term="AIGen" scheme="http://www.calvinneo.com/tags/AIGen/"/>
    
    <category term="profiling" scheme="http://www.calvinneo.com/tags/profiling/"/>
    
    <category term="RDMA" scheme="http://www.calvinneo.com/tags/RDMA/"/>
    
  </entry>
  
  <entry>
    <title>一个 RDMA visibility 问题的讨论</title>
    <link href="http://www.calvinneo.com/2026/10/14/rdma-visibility/"/>
    <id>http://www.calvinneo.com/2026/10/14/rdma-visibility/</id>
    <published>2026-10-14T14:48:32.000Z</published>
    <updated>2026-10-26T14:27:45.372Z</updated>
    
    <content type="html"><![CDATA[<p>这组实验在 GPU 和 PPU 上检查 RDMA Write 之后的 GPU visibility，并对比一个 flush workaround 的效果。在已完成的测试中，启用和关闭 workaround 都没有复现不一致。</p><a id="more"></a><h2 id="实验目标：RDMA-Write-的-GPU-visibility"><a href="#实验目标：RDMA-Write-的-GPU-visibility" class="headerlink" title="实验目标：RDMA Write 的 GPU visibility"></a>实验目标：RDMA Write 的 GPU visibility</h2><p>本次实验检查一个具体流程：发送端收到确认本轮最后一个 RDMA Write 的 ACK，通知接收端，接收端在目标 GPU 上 launch kernel。这个 kernel 应当从接收 buffer 中读到本轮的完整数据。如果仍然读到上一轮内容或新旧混合的数据，就是要捕获的 visibility 问题。</p><p>“收到最后一个 ACK”在程序中的判断标准是：在同一条 RC（Reliable Connected）QP 上按序提交本轮 Write，每次提交的操作称为 WR（Work Request），只给最后一个 WR 设置 <code>IBV_SEND_SIGNALED</code>，要求它产生 CQE，并等待该请求成功完成。CQE 是网卡提供给应用的 completion 记录，程序检查 <code>status == IBV_WC_SUCCESS</code>、<code>opcode == IBV_WC_RDMA_WRITE</code>，以及 <code>wr_id</code> 属于本轮最后一个 WR，再通过 TCP 发送 <code>WRITE_DONE</code>。[6] 程序通过 CQE 判断 ACK 对应的 Write 已完成，不直接读取 ACK 报文。<code>WRITE_DONE</code> 负责把这个结果转告接收端。</p><p>NVIDIA 文档指出，已经运行的 kernel 与外部 RDMA Write 并发访问同一块 GPU memory、缺少相应同步时，会有读到旧数据、部分更新或乱序更新的风险。[1] 当前实验检查的是完成 ACK 之后再 launch kernel 的流程，不能仅凭网卡确认写完，就省略对 GPU 读取结果的验证。</p><p>为了做对照，测试程序实现了一段类似 <code>cuFlushGPUDirectRDMAWrites()</code> 的 workaround：在接收端 launch kernel 前，额外执行一次 RDMA Read，并等待它完成。具体做法是让本机网卡通过一条自连的 QP，也就是 loopback QP，从刚写入的 GPU buffer 读一个 byte 到临时 host buffer。这个额外读取称为 readback，长度 1 是 workaround 的请求设置，NCCL 的公开实现也有类似做法。[2] 读取的值不参与校验，程序只等待 Read completion。</p><p>OFF 跳过 workaround，ON 执行 workaround，两组都不调用原生 <code>cuFlushGPUDirectRDMAWrites()</code>。这里比较的是这段额外代码能否消除不一致，尚未证明它与原生 API 的保证等价。</p><h2 id="基础实验：同机-RDMA-传输与设备端校验"><a href="#基础实验：同机-RDMA-传输与设备端校验" class="headerlink" title="基础实验：同机 RDMA 传输与设备端校验"></a>基础实验：同机 RDMA 传输与设备端校验</h2><p><strong>假设。</strong> 目标错误应当表现为 GPU kernel 读取 RDMA 写入的 buffer 时发生不匹配。基础实验需要验证这条直接写入 GPU memory 的路径，并建立 OFF/ON 对照。</p><p><strong>验证。</strong> 先在两台 PPU 主机之间用 host memory 跑通 RDMA Write，确认网络和 memory registration 可用。随后测试同机 GPU memory，先用 loopback，再拆成独立的发送、接收进程。payload 始终经网卡写入 GPU memory，TCP 只传通知。每轮执行：</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br></pre></td><td class="code"><pre><span class="line">接收端初始化 result buffer，允许本轮写入</span><br><span class="line">    → 发送端提交本轮 RDMA Write</span><br><span class="line">    → 发送端等到最后一个 Write 的成功 CQE，发送 WRITE_DONE</span><br><span class="line">    → 接收端收到 WRITE_DONE</span><br><span class="line">    → OFF 直接继续，ON 执行 workaround 并等待 Read completion</span><br><span class="line">    → 在目标 GPU 上 launch 校验 kernel</span><br><span class="line">    → kernel 完成，返回校验结果，再允许下一轮写入</span><br></pre></td></tr></table></figure><p>数据随轮次和位置变化，kernel 直接比较注册给网卡的 GPU buffer，CPU 只取回小块 result。下一轮等待本轮校验结束，避免提前覆盖 buffer。</p><p><strong>结果与分析。</strong> OFF 和 ON 都通过，说明这条传输、通知、kernel 校验的流程能够运行。由于 OFF 没有读错，这一步无法证明 workaround 有效，后续继续改变写入条件。</p><h2 id="PPU：单连接负载与-WR-拆分"><a href="#PPU：单连接负载与-WR-拆分" class="headerlink" title="PPU：单连接负载与 WR 拆分"></a>PPU：单连接负载与 WR 拆分</h2><h3 id="payload-大小与-WR-数量"><a href="#payload-大小与-WR-数量" class="headerlink" title="payload 大小与 WR 数量"></a>payload 大小与 WR 数量</h3><p><strong>假设。</strong> 单轮访问范围太小，或者一轮只有一个 Write，未覆盖目标错误需要的条件。增加 payload 和 WR 数量，用来检查这两个因素。</p><p><strong>验证。</strong> PPU 单连接测试覆盖下表中的配置。大小和轮数按测试目的与运行预算选取，表中每行分别用 1 个和 16 个 WR 发送。</p><table><thead><tr><th>每轮 payload</th><th align="right">每种配置的轮数</th><th>目的</th></tr></thead><tbody><tr><td>4 KiB</td><td align="right">2</td><td>基础检查</td></tr><tr><td>1 MiB</td><td align="right">1000</td><td>反复写入和校验</td></tr><tr><td>64 MiB</td><td align="right">10</td><td>扩大单轮访问范围</td></tr></tbody></table><p>例如 1 MiB 拆成 16 个 Write，每个就是 64 KiB。总数据量相同，变化的是请求拆分，避免把这两个变量混在一起。</p><p><strong>结果与分析。</strong> 三种大小、两种拆分的 OFF/ON 都通过。当前范围内，扩大 payload 和增加 WR 没有得到失败的 baseline。</p><h3 id="SYNC-MEMOPS"><a href="#SYNC-MEMOPS" class="headerlink" title="SYNC_MEMOPS"></a>SYNC_MEMOPS</h3><p><strong>假设。</strong> 测试中的 CUDA memory operation 带来了额外同步，掩盖了 OFF/ON 差异。<code>CU_POINTER_ATTRIBUTE_SYNC_MEMOPS</code> 是需要检查的一个变量。</p><p><strong>验证。</strong> 上述矩阵同时比较该属性的 0/1 设置。按 CUDA 定义，它作用于一块 allocation，开启后要求这块 memory 上的 synchronous memory operation 确实按同步语义完成。[3] 例如 CPU 调用 <code>cuMemcpyDtoD()</code> 后立刻让网卡读目标地址，该属性会禁止 copy 仅排入队列就向 CPU 返回的优化，确保 copy 完成后才开始后续访问。[1] 它约束这些 CUDA 操作，不会等待未来的 RDMA Write。这里引用的是 CUDA 语义，没有验证 PPU 内部是否采用相同实现。</p><p><strong>结果与分析。</strong> 每种 payload 覆盖 WR 数 1/16、属性 0/1、OFF/ON，即 <code>2 × 2 × 2 = 8</code> 种配置，合计 24 种组合全部通过。关闭该属性仍未复现，但这不表示测试已移除所有同步：接收端仍然在 <code>WRITE_DONE</code> 之后才 launch 新 kernel。</p><h2 id="OWNER-memory-ordering"><a href="#OWNER-memory-ordering" class="headerlink" title="OWNER memory ordering"></a>OWNER memory ordering</h2><p><strong>假设。</strong> GPU 已经为目标 GPU 上的 kernel 提供所需的 native memory ordering，因此不加额外 flush 也能读对。</p><p><strong>验证。</strong> 查询本次 GPU 的 <code>CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_WRITES_ORDERING</code>，返回 <code>100</code>，对应 <code>OWNER</code>。这个属性描述外部 RDMA Write 对哪些 GPU 上的读取提供 native ordering。CUDA 的枚举值为：[4]</p><table><thead><tr><th align="right">返回值</th><th>名称</th><th>保证范围</th></tr></thead><tbody><tr><td align="right">0</td><td><code>NONE</code></td><td>没有 native remote-write ordering 支持</td></tr><tr><td align="right">100</td><td><code>OWNER</code></td><td>拥有目标 memory 的 GPU 能一致地读取 remote writes</td></tr><tr><td align="right">200</td><td><code>ALL_DEVICES</code></td><td>上述保证扩展到系统内其他 CUDA device</td></tr></tbody></table><p>例如网卡写入 GPU A 的 memory，随后在 A 上 launch kernel 校验，就在 <code>OWNER</code> 范围内。即使数据来自 GPU B，只要 kernel 仍在 A 上读取 A 的 memory，范围也没有变化。若改成 B 上的 kernel 直接读取 A 的目标 memory，才需要其他 GPU 的保证。</p><p><code>cuFlushGPUDirectRDMAWrites()</code> 的 scope 指要求哪些 GPU 能读到 remote writes，<code>TO_OWNER</code> 只要求拥有目标 memory 的 GPU。CUDA 规定，scope 已被设备的 native ordering 覆盖时，调用就是 no-op。[5] 因此，本次报告 <code>OWNER</code> 的 GPU 上，<code>TO_OWNER</code> flush 可以省略。</p><p><strong>结果与分析。</strong> 对本次由 GPU 读取自身 memory 的测试，去掉这个原生 flush 并没有撤掉一项必要保证。这为 GPU 的通过结果提供了解释，但不能用于推断 PPU 的实现。原生 API 的 no-op 也不表示 workaround 中的 RDMA Read 没有执行。无论是否需要 flush，发送端仍要等本轮最后一个 Write 的成功 CQE，接收端才开始后续校验。</p><h2 id="GPU：显式-flush-与传输路径对照"><a href="#GPU：显式-flush-与传输路径对照" class="headerlink" title="GPU：显式 flush 与传输路径对照"></a>GPU：显式 flush 与传输路径对照</h2><p><strong>假设。</strong> 显式 flush 或 <code>WRITE_DONE</code> 与 kernel launch 之间的其他操作消除了待观察的差异，或者此前的数据路径没有覆盖触发条件。</p><p><strong>验证。</strong> 随后开展的独立实验移除了显式 CUDA flush。kernel 和 result buffer 提前准备、预热，收到 <code>WRITE_DONE</code> 就 launch 校验 kernel，中间不插入整块 payload 的 readback、清零、allocation 或显式 CUDA synchronization。</p><p>这组同时覆盖 RDMA 的 H2D 和 D2D，以及同网卡、不同网卡和两个传输方向。最大场景的单轮有效 payload 超过 1 GiB，用于扩大访问范围。该组保留 <code>SYNC_MEMOPS=1</code>，没有做 workaround 的 OFF/ON 对照。</p><p><strong>结果与分析。</strong> 各场景都通过。换了数据来源和网卡路径，校验 kernel 仍在目标 GPU 上运行，并且在收到 <code>WRITE_DONE</code> 后才 launch。因此，D2D 没有改变 <code>OWNER</code> 的适用范围，也没有检验已经运行的 kernel 如何观察外部写入。</p><h2 id="并发负载与-validator-检查"><a href="#并发负载与-validator-检查" class="headerlink" title="并发负载与 validator 检查"></a>并发负载与 validator 检查</h2><h3 id="并发-sender-与重复轮数"><a href="#并发-sender-与重复轮数" class="headerlink" title="并发 sender 与重复轮数"></a>并发 sender 与重复轮数</h3><p><strong>假设。</strong> 单连接负载不足以触发不一致，需要增加同时传输的 sender 数量和重复次数。</p><p><strong>验证。</strong> 后续的 GPU 长测使用 64 和 128 个 sender，每个 sender 每轮传 1 MiB、拆成 16 个 Write，分别运行 100 和 1000 轮，并覆盖 <code>SYNC_MEMOPS</code> 0/1 与 OFF/ON。这些数值来自选定的并发规模和测试预算。PPU 也测试了 64 和 128 个 sender，但每轮每个 sender 只传 4 KiB、运行三轮，用于检查并发实现能否运行。</p><p><strong>结果与分析。</strong> 两种平台的组合都通过，但 PPU 没有覆盖 GPU 的长测。每个 sender 使用独立 buffer，自己的 Write 完成后才 launch 校验 kernel。因此，即使出现读取已写完的 buffer A 与写入 buffer B 的重叠，也没有让 kernel 与网卡并发访问同一个 buffer。日志里的 64 或 128 个窗口按 READY 到结果返回计数，只证明轮次重叠，不能据此认定同样数量的 kernel 同时执行。</p><h3 id="WR-拆分补测"><a href="#WR-拆分补测" class="headerlink" title="WR 拆分补测"></a>WR 拆分补测</h3><p><strong>假设。</strong> 前面的 16 个 WR 还不足以触发目标现象，进一步拆细请求能检验这一点。</p><p><strong>验证。</strong> GPU 上用四个 sender、每个十轮，每轮仍传 1 MiB，但拆成 256 个 Write，即每个 4 KiB。这组关闭 <code>SYNC_MEMOPS</code>，分别运行 OFF 和 ON。sender 数和轮数是补测规模，主要变化是单轮 WR 数量。</p><p><strong>结果与分析。</strong> 两组仍然通过。更细的请求拆分没有改变“最后一个 Write 完成后再 launch kernel”的顺序。</p><h3 id="validator-检查"><a href="#validator-检查" class="headerlink" title="validator 检查"></a>validator 检查</h3><p><strong>假设。</strong> 连续 PASS 也需要排除 validator 漏报错误。</p><p><strong>验证。</strong> GPU 的 H2D、D2D 测试故意跳过某轮 Write，仍按新一轮内容校验。并发版另外检查了设备校验失败、kernel launch error 和错误 CQE 的传播。</p><p><strong>结果与分析。</strong> 跳过 Write 后，kernel 识别出了旧数据，错误也传回发送端。其他错误没有被汇总成成功。这验证了检测链路，但人工留下旧数据与自然出现的 visibility 问题不是同一个原因。</p><h2 id="实验局限：kernel-launch-时序"><a href="#实验局限：kernel-launch-时序" class="headerlink" title="实验局限：kernel launch 时序"></a>实验局限：kernel launch 时序</h2><p>现有实验一直保留同一条顺序：<strong>最后一个 Write 获得 ACK，发送端取到成功 CQE 并发送 <code>WRITE_DONE</code>，接收端收到通知后 launch 新 kernel。</strong> NVIDIA 文档把 CPU 发起的相关 CUDA work submission 和 synchronization API 列为建立 GPUDirect RDMA ordering 的机制，前提是外部写入在提交依赖 kernel 前已经完成。[1] 这与 GPU 的 <code>OWNER</code> 一起解释了为什么关闭显式 flush 仍然正确。</p><p>剩下的一个待验证假设是 kernel 的运行方式。<strong>persistent kernel</strong> 指一次 launch 后留在 GPU 上等待后续轮次的 kernel，它不会每轮都经过新的 CPU launch。当前实验没有覆盖这个条件，原始失败场景也没有被完整还原，不能把它直接写成根因或保证能够复现的方案。</p><p>后续验证需要保留同样明确的完成条件，并说明 persistent kernel 怎样得知本轮已写完、何时读取 buffer，以及何时允许下一轮覆盖。用于通知 kernel 的标志与 payload 之间需要平台支持的同步保证，不能仅把 CPU 线程间的 release/acquire 写法搬过去就认定成立。</p><p>对 PPU，记录只支持当前流程全部通过，缺少进一步解释内部机制的证据。记录也没有测出 <code>WRITE_DONE</code> 到实际读取的间隔，不能把通知耗时当作已确认的原因。当前结论仍是：未得到 OFF 失败、ON 成功的对照，因此尚未证明 workaround 的必要性或它对原始问题的修复作用。</p><h2 id="参考资料"><a href="#参考资料" class="headerlink" title="参考资料"></a>参考资料</h2><p>实验参数与结果来自本次记录。以下公开资料用于核对 API 语义。</p><ol><li><a href="https://docs.nvidia.com/cuda/gpudirect-rdma/index.html#synchronization-and-memory-ordering" target="_blank" rel="noopener">GPUDirect RDMA: Synchronization and Memory Ordering</a>。</li><li><a href="https://github.com/NVIDIA/nccl/blob/v2.27.7-1/src/transport/net_ib.cc" target="_blank" rel="noopener">NCCL v2.27.7-1 RDMA implementation</a>：loopback readback、请求长度和 <code>ncclIbIflush()</code>。版本用于固定源码依据，不代表实验环境。</li><li><a href="https://docs.nvidia.com/cuda/archive/13.0.1/cuda-driver-api/group__CUDA__UNIFIED.html" target="_blank" rel="noopener">CUDA 13.0.1: Unified Addressing</a>。</li><li><a href="https://docs.nvidia.com/cuda/archive/13.0.1/cuda-driver-api/group__CUDA__TYPES.html" target="_blank" rel="noopener">CUDA 13.0.1: Data Types</a>。</li><li><a href="https://docs.nvidia.com/cuda/archive/13.0.1/cuda-driver-api/group__CUDA__DEVICE.html" target="_blank" rel="noopener">CUDA 13.0.1: Device Management</a>：flush scope 与 no-op 条件。</li><li><a href="https://networking-docs.nvidia.com/doca/sdk/rdma-aware-networks-programming-guide" target="_blank" rel="noopener">RDMA-Aware Networks Programming Guide</a>：<code>ibv_post_send()</code>、<code>ibv_poll_cq()</code> 与 completion 状态。</li></ol>]]></content>
    
    
    <summary type="html">&lt;p&gt;这组实验在 GPU 和 PPU 上检查 RDMA Write 之后的 GPU visibility，并对比一个 flush workaround 的效果。在已完成的测试中，启用和关闭 workaround 都没有复现不一致。&lt;/p&gt;</summary>
    
    
    
    
    <category term="网络" scheme="http://www.calvinneo.com/tags/网络/"/>
    
    <category term="AIGen" scheme="http://www.calvinneo.com/tags/AIGen/"/>
    
    <category term="RDMA" scheme="http://www.calvinneo.com/tags/RDMA/"/>
    
  </entry>
  
  <entry>
    <title>健身房训练纪实</title>
    <link href="http://www.calvinneo.com/2026/10/12/gym/"/>
    <id>http://www.calvinneo.com/2026/10/12/gym/</id>
    <published>2026-10-12T15:07:22.000Z</published>
    <updated>2026-10-24T08:34:32.916Z</updated>
    
    <content type="html"><![CDATA[<p>从 Oct 12 开始训练。</p><a id="more"></a><h1 id="健身房选择"><a href="#健身房选择" class="headerlink" title="健身房选择"></a>健身房选择</h1><h1 id="Oct-12"><a href="#Oct-12" class="headerlink" title="Oct 12"></a>Oct 12</h1><p>今天主要是进行了一些功能性训练。</p><p>我发现我的肩背确实有很大问题，例如我的弹力带招财猫动作会非常的疼。右边会比左边疼，最后拉伸的时候也是这样。</p><p>直臂收腹做的我想吐，教练说还是呼吸问题。说我跑步第 10min 到第 20min 有呕吐感是因为不会呼吸。</p><p>高位下拉感觉做的还是可以的，因为是反手的，所以手臂还是比较酸的。可以把注意力放到肩背，这样就不会斜方肌代偿了。不过后面做不动了会斜方肌代偿，这个时候就没必要再做了。</p><p>最后进行拉伸，在拉伸胸部和肩膀的时候非常疼，特别是要把两个手臂拉到最后面。我觉得这个还是和我的圆肩和肱骨前移有关。</p><h1 id="Oct-14"><a href="#Oct-14" class="headerlink" title="Oct 14"></a>Oct 14</h1><p>今天主要是练腿。</p><p>之前轻一磅的教练说我腿前面还行，后面缺少肌肉。说我屁股还行，所以腰椎没问题。不过今天看下来，腿后面的力量反而比前面大一点，都属于新手水平。屁股肌肉好像一般，主要是因为我做练屁股的动作的时候，屁股没感觉。</p><h1 id="Oct-16"><a href="#Oct-16" class="headerlink" title="Oct 16"></a>Oct 16</h1><p>今天主要是练肩颈背。</p><p>主要几个动作，可以平时做做：</p><ul><li>海豹伸展</li><li>趴着上下活动肩胛骨，配合呼吸</li></ul><h2 id="练习的主要是："><a href="#练习的主要是：" class="headerlink" title="练习的主要是："></a>练习的主要是：</h2><p>做了下躺着的仰头训练，结果第二天脖子前侧非常疼。</p><h1 id="Oct-19"><a href="#Oct-19" class="headerlink" title="Oct 19"></a>Oct 19</h1><p>今天练腿。</p><p>做了屈伸 50kg，没有做弯举。不过这次加了深蹲（前面抱着空杆）、弓箭步、高抬腿弯举。高抬腿弯举因为用了肩膀，所以又累又疼。</p><p>整个训练过程不是特别累，但是第二天腿直接疼得路走不了了。</p><p>拉伸非常疼，主要是三个部分，小腿弯折，胯部外翻折，还是最疼的整条大腿拉伸。</p><h1 id="Oct-21"><a href="#Oct-21" class="headerlink" title="Oct 21"></a>Oct 21</h1><p>今天是肩颈背和核心。</p><p>主要是：</p><ul><li>X 外展<br>  肩膀和斜方肌非常疼，虽然这个是练肩后束的，但是确实发力感很有</li><li>人倒着把自己拉起来，应该是练背的</li><li>坐姿划船</li><li>辅助引体<br>  一开始还行，后面行程长了之后，手臂就贼疼</li><li>高位下拉<br>  这次直接是用杆子了。从 14kg 开始加了两次，这里的重点是手臂要直上直下，并且不要弯折。</li></ul><p>发现一个动作还不错，就是趴着，然后一个手臂上，一个手臂下，然后来回转换，用来锻炼肩部的稳定性。</p><p>核心这边就是仰卧起坐，这次是直接平躺+负重，我做了一组就起不来了，第二组只能屈膝加不负重。</p><p>第二天主要还是腹部比较酸痛，但是感觉肩背没有特别酸痛，手臂有点。</p>]]></content>
    
    
    <summary type="html">&lt;p&gt;从 Oct 12 开始训练。&lt;/p&gt;</summary>
    
    
    
    
    <category term="运动" scheme="http://www.calvinneo.com/tags/运动/"/>
    
  </entry>
  
  <entry>
    <title>越南游记</title>
    <link href="http://www.calvinneo.com/2026/10/08/meet-in-vietnam/"/>
    <id>http://www.calvinneo.com/2026/10/08/meet-in-vietnam/</id>
    <published>2026-10-07T17:20:33.000Z</published>
    <updated>2026-10-12T05:07:25.866Z</updated>
    
    <content type="html"><![CDATA[<p>国庆节和鑫鑫去了越南。</p><a id="more"></a><h1 id="Pre"><a href="#Pre" class="headerlink" title="Pre"></a>Pre</h1><p>本来是准备去印尼的，但是时间不够，然后那个布啥的火山好像不是很太平，没敢去。后面又打算去柬埔寨，不过那个团说机票突然涨了 3000。最终决定去越南，中午定好，准备下午买票的时候发现胡志明的也涨价了，于是只能赶快把河内的买了。</p><h1 id="D0-Sep-29"><a href="#D0-Sep-29" class="headerlink" title="D0 Sep 29"></a>D0 Sep 29</h1><p>六点出头就下班了，回去收拾了下，准备乘坐倒数第二班机场联络线去 pvg。</p><p>中途发现自己 codex 被封号了。</p><p>咸鱼买的休息室，试了几个都不能用，非常难受。最后只能硬等，不过好在其实也没有多久了，我把那个干拌面泡了，鑫鑫定了下明天巴拿山的门票。然后因为要填 WhatsApp，所以我临时注册了一下。</p><h1 id="D1-Sep-30"><a href="#D1-Sep-30" class="headerlink" title="D1 Sep 30"></a>D1 Sep 30</h1><p>到了河内机场 T2，入境还是比较顺利的。没有要小费的地方，确实也是右边的队伍更快。入境之后就可以取行李，然后过海关的时候所有包都需要过，只开了一个机器，但是也不是很堵。出了海关，我们就打算换汇+买电话卡。我们跑了几个地方，拿到的是 3750 的汇率。一般换汇的地方也可以买电话卡，不过我们选了一个 vietel 的，因为鑫鑫查了下，这家信号好。我们和他讨价还价了好久，拿着中国移动漫游的价格给他看，就给我们便宜了一万，我也是乐了。结果买了他给我们一个 esim 的二维码，我说我们不支持 esim。完了就直接买中国移动的漫游算了，5 天才 51 块钱，很划算了。</p><p>从 T2 到 T1 需要坐免费的 shuttle bus，而我们到 T1 吃早饭是非常明智的，因为 T2 真的非常贵（至少走的时候在国际出发是这样的）。越南的机场安检也是非常魔怔，每次都得看护照和签证，这边电脑啥的也得拿出来，还得脱鞋子。进去之后，我们就找了一家小红书上有名的 truly honoi 店，点了个河粉和鸡蛋咖啡。河粉很好吃，鸡蛋咖啡喝不惯，那个咖啡感觉是速溶的还是啥的，反正比较苦，但是鸡蛋浮在上面，有点像一层厚厚的沫一样，特别甜。但是喝的时候又没法一口抿两个（鸡蛋太稠了），所以就是一口甜一口苦的。</p><p>飞岘港的飞机非常拉胯，比如它居然不能把我们分得坐在一起。飞机上，被一堆印度人包围了。我觉得他们挺莫名其妙的，感觉好像是一家子人，但是做个事情就要争论很久。因为我坐中间嘛，靠窗户的那个年轻女的要进去，我都站起来了，结果外面的好像她妈妈不让，我纯罚站了会。然后中途里面的女的又要上厕所，我站起来了，她妈妈也是不肯挪出来。然后她们又找后面的人说要和我换位置，我这倒无所谓。然后后面很远的一个男的又说要和我换，我寻思我包还在上面的，这也太能换了，就拒绝了。反正最后我被换到那个年轻女的的座位，然后她包还在下面，要我拿给她。待会又要我拿水，我用脚踢给她，她弄了会好像又没了，要我帮忙拿，我说我够不到。下了飞机在行李带旁边，看到她的行李又对我们笑，我寻思你这也太奇怪了，我也没给她拿。</p><p>落地岘港，我们自己打车去 Paris Deli 酒店。这边 grab 非常方便，是可以信用卡付款的。机场的话，并不是打车车开过来，而是车就可以在一个地方（非常近）等，然后你到了那边就可以上车了。酒店很便宜，一晚才 250+。不过不能提前入住，我们也不是看海的房间。</p><p>先放行李，我确实背不动，所以纠结了下，就全存了。我就带了个手机，就出去吃饭了。这边遍地米其林，先吃了个叫 BEP CUON 的店。点了一些东西。影响比较深刻的是它有一个很硬的像是豆皮一样的东西，但是它是非常透明的，好像是粥上面的粥皮的感觉，但是摸上去又很油，应该是炸出来的，要用那个东西去包一堆东西吃，包含</p><p>吃完，就去附近的一个按摩。这个按摩装饰还可以，不过就两个人。一个人我本来以为是前台，结果到时候按摩也是她和另一个黑衣服的妹子。</p><p>按摩完，刚好到了入住时间。有一个窗户，开出来是对着隔壁楼的墙，这边也有点握手楼的感觉。然后手机伸出窗子，往右拍，可以看到一线海景。我进去睡了会，鑫鑫去逛了下宾馆，然后我们出发去海滩。</p><p>海滩上人是很多的，但是也不挤，因为这个海滩真的是非常长。我们去的时候阳光很好，很多人直接泡在海里面。沙滩是非常脏的，不仅有树枝或者海里冲上来的植物，也有人们乱扔下来的东西。沙滩上还有一些椰子船，但是没人玩。离海更远的沙滩上，有人搭起来了几个沙滩排球场地，大家很舒服。</p><p>我们从海滩出来打车，第一个司机不愿意接我们，说我们很湿，估计是看到我们鞋子上都是沙子。然后我们就找了个厕所冲脚，然后就被一个清洁工奶奶看到了，痛骂，意思是要在外面那个专门的地方冲脚。冲完脚，擦了下，找了另外一个司机，他倒是没什么废话讲。他不会英语，但是很麻烦的用了翻译软件告诉我们说看日落的那边在山上，打不到回来的车，说在那边等我们。</p><p>我们回来就类似于包车那种了，直接给他现金。他把我们放到龙头桥下面，过了马路是一个夜市，里面一堆人说中文，我们赶快跑了。前面有个 che lien 的甜品，走到那边，他家门面有两条狗。老板娘拿了菜单，我看里面全是咖啡和果汁，我就说我们要吃那个 durian 的糖水，老板娘一脸懵逼，说没这东西。磨蹭了半天，我们就觉得找错地方准备走了，结果我在门口的灯箱上看到了，就指给她看，老板娘恍然大悟，说这个是 duran，所以他们的口音真的很奇怪。这个糖水挺便宜的，不过量也不是很大。里面不止有榴莲，还有一种亮晶晶的，有点像是果冻，或者那种高速服务区里面经常见到的硬硬的透明粉的那种东西。</p><p>岘港有个特别有名的海鲜料理，就在我们宾馆旁边，不过我们过去的时候已经是人山人海了，于是我们果断走了。我本来想吃那个八戒海鲜的，但是鑫鑫说烤肉不错，所以我们去了一家韩国烧烤，veteran 老兵烧烤。感觉还是挺贵的，我们就点了个三个肉的拼盘，就花了 124 万 vnd 了。不过所幸是他家的小菜不贵，而且特别多，各种小菜直接给我吃饱了，所以其实还行。</p><h1 id="D2-Oct-01"><a href="#D2-Oct-01" class="headerlink" title="D2 Oct 01"></a>D2 Oct 01</h1><p>早上非常早就起来拍日出了，我大概是五点不到出门，五点的时候已经在沙滩上了，鑫鑫走的更早。</p><p>今天是巴拿山一日游，我们的司机还是非常不靠谱的。因为昨天就接送时间，我们都没有聊得很明白，当然 klook 自己也很乱。其实我们 kllok 515 的就是包含包车接送了，根本不需要考虑那个市区在 8.30 出发的大巴，那个 shuttle bus 是流水发车的，车程就 5min，不是市区出发的那个接送大巴。然后我们昨天 WhatsApp 上说的其实就是把这两个东西线混为一谈。</p><p>总之，我说我们 7.30 出发，然后他说堵车，结果 7.40 才到。这司机会说英语，所以一路跟我们讲解各种玩法。我问了下他昨天说的两个景点，他说那个什么就是类似吴哥窟（其实我不知道吴哥窟怎么说，不过他说了柬埔寨我就懂了）的神庙，不过是印度教的。最后，他又强烈推荐了会安。</p><p>从摆渡车下来，我们给服务人员看了下我们的 klook 预定，就会得到一个手环。这个手环其实就是一个 fast pass，比如可以免索道排队啥的。我们随即就体会到了，因为我们在前往上山索道的时候，直接就是走的一个专门的通道，而其他人是走的另一个通道。不过另一个通道也不像国内一样堵，所以是纯情绪价值。在索道口，我们的手环上的二维码并没有用，因为还是要出示 klook 上的预定码才行。</p><p>上了缆车，这个缆车是真的长啊，比张家界的还长。经过了好久，我们到达了山顶。一眼就能看到那个佛手桥。佛手桥上全是人，基本山没有办法拍照，我们从一端走到一端就出去了。在另一端有个平台，可以站在上面拍照，我们当时去的时候还在排队，反倒是我们后面逛了一圈准备去 B1 的时候，不需要排队了。</p><p>值得一提的是，在前往 Le jardin d’amour 时，我发现头顶怎么还有个缆车，这是去哪里的？后面拿着地图才知道，这地方有 9 条缆车，我们坐的上山缆车是从 Hoi An 到 Marseille 的。而整个佛手桥地区称为 B2，这个区域主要是一些法式花园，和一些佛教文化的东西。比如从爱情花园往前走，走过一条小径，旁边突然是西游记取经人的四个雕塑，孙悟空唐僧啥的都非常抽象。再往前走，又是一些花里胡哨的花园。比如一个地方是一个手捧爱心，一个地方有一堆罗马柱，一个地方又有一个国际象棋棋盘，还有一个面朝群山的广场上有一个巨大的躺着的孔雀。就是说虽然这边反差感比较大，看的出来是在仿造，但是他们做的东西的审美，以及质感，我觉得还是比中国的景区要好的。再往前走，就可以走到一个佛塔那里，然后再往前走，还有一个像寺庙一样的地方。穿过一个过道，就可以到达 B2 的最东面，是一个很大的露台，从那边还可以看到其实是 A 区的东西，比如我们后面要坐的那个 coaster。</p><p>逛完，我们就准备去 B1 区了。问了下路，其实就是在一个巨大的圆形顶棚的建筑里面，顺着人流走就到了。坐上缆车，我们到达的是 LOUVRE 站。这里需要简单提及的是，越南的站会写成 GA，我觉得实际上就是法语的 gare 简化了的。那出了这个站，这边还是比较乱的，有非常多的层，以及非常多的扶梯，并且吃中午饭的那个自助餐厅也在这里，我觉得要是停电了这边根本就没法走。无论如何，我们终于走出了建筑，然后外面就是非常法式的建筑，有非常多的石头雕塑，一些浮夸的拱门，最离谱的是有一个模仿卢浮宫的金字塔，但是非常丑。</p><p>我们往月亮城堡的方向走，也就是整个 B1 区的最西边，等玩结束了，一直往东就可以不回头了。一路上我们经过了很多神话任务的雕塑，比如 fortuna、venus 等等。月亮城堡的外观是比较好看的，他有点像矮胖版的霍格沃茨城堡，但是城堡外围还写了很多漂亮的水池和花卉。另外一个方向还有个 BAND 花园，里面有一个月球雕塑，我觉得很漂亮。</p><p>进到月亮城堡里面，其实倒也比较空旷，一进去有一些娱乐设施，比如类似于套圈的东西，赢了就可以拿个超大娃娃，没人玩，毕竟谁也不想拿个超大娃娃上飞机。月亮城堡里面主要是两个演出。第一个是一个 4D 剧院，就是基于园区的娱乐项目搞了个动画，讲了一家人出去玩，妈妈的幻想，没啥意思，不过确实是被旁边的喷气吓到了。第二个是一个飞越地平线一样的东西，我们去的时候大排长龙，我怀疑是跟了个旅游团后面了。这里比较坑的是需要 golden pass 才能免排队，但是我们的是 silver pass。这边一共有两个大厅，每个大厅一次可以坐 20 个人，一次体验是要 7 分钟，我们等了三波才进去。进去之后，发现非常搞笑。比如要到埃及的时候，突然天花板上一个浴霸就亮了，突出一个埃及的晒。然后到伦敦的时候，猛不丁的，一个自由女神像就从威斯敏斯特里面升起来了，然后画面就切换到纽约。不得不说，这是不是被法国殖民之后的恶趣味呢？最后一站是台湾，而切换到它的场景则是飞机在雷雨中，不知道是不是台湾过去空难比较多？</p><p>我们是坐了 18 的那个小火车回程的，地图上标的是到 solar castle，但是它实际上是把我们送到了 LOUVRE 那个楼里面，或者它的隔壁楼，反正我们就直接去吃中饭了。</p><p>我们有个 four seasons 的自助餐，进去的时候人山人海。这个自助餐东西还不少，不过好的不是很多。比较有特色的是越南特色小吃档口，有一个米糕味道独特，还有一个是粽叶上插了块肉，实际上是鱼肉，很鲜美。大部分人就是会排螃蟹，排螃蟹的地方还会有一些蛤蜊（很大）和虾啥的。另一些人会排牛排，牛排并不好吃。这里还吃到了一个很奇怪的甜品，感觉就是一种比较甜的汤，里面又加了一些圆子、桃胶之类的东西。</p><p>吃完饭，正好看到 coaster，于是就进去坐。这里排队还挺多的，不过我们的 fast pass 依旧没有用，因为同样需要 golden 的才行，所以我们只能挤普通人的队伍。不过这个队伍是非常快的，后来我们才知道，这个队伍对应两个轨道，等我们进去存完包之后，就会上楼，在楼上队伍就会分成两部分。我们站在二层的平台上可以看到下面人出发和到达。其实这个车是可以两个人坐的，比如很多情侣就坐一辆车。到达的时候，很多人会把持不住刹车，结果猛撞一下前车。于是我有点担心我的颈椎，后悔自己没把那个脖撑拿出来。不过等坐上车感觉就多虑了，因为在轨道上其实是有防撞的，就是哪怕你杆推到底，只要前面有人，你速度也起不来。要到我们的时候，感觉天突然暗了下来，我们很怕要下雨，结果只是雾气。同时我们可以看到出发的那个口子的对面，好像还有两个轨道，也有 coaster 从那里面出来。后来我们才知道，这边有两个 coaster。</p><p>坐完 coaster 出来的时候，发现天就是晴的，可是刚才我们在的地方还全是雾气啊。难道是 coaster 自己造的雾？后来发现不是这样，因为几秒钟之后，一些雾气飘来，瞬间刚才的感觉又回来了。所以说确实山上的天气可能是千变万化的。</p><p>在法国小镇，我们点了越南专属的 coconut dolce espresso。还被暗搓搓加了一点咖啡液，因为收银员问我是 medium 还是 strong，我选了 medium，但后来感觉其实可以说 basic 的吧。我们在外面的桌子等了很久咖啡才做好，真的是非常慢。不过我们还点的一个也说是越南专属的面包是加温好的，感觉还是很好吃的。叫 Hot Ham &amp; Cheese Patini，芝士不是特别甜。</p><p>从咖啡那边出来，就往瀑布和啤酒那边跑了。找到了那个啤酒工厂，因为刚喝完咖啡，所以不是很想立刻喝啤酒，就逛了下。这边同样是一些法国小镇，规模还是比较大的。这些小镇其实也就是商业街，有很多吃饭和按摩的地方。这边很有意思的是，在某个地方，突然就可以上山，然后一个牌匾出现在你眼前，上面是汉字。没错，我们突然就切换到了一个汉传佛教的寺庙领地里面了。我们需要小爬一段山，就可以到达巴拿山的最高点。在上面有一些殿，还有一个阁。阁上面有一些石头佛像，还有一口钟，这口钟是一个机器人在撞。所以在这个中式的阁上，你可以排到机器人在撞钟，一些石塑佛像，以及远处的法式城堡，真的是很离谱了。</p><p>喝啤酒的时候，司机在 WhatsApp 上和我说，到达时间超过 18 点，会按照一小时十万额外计费。我看了下时间，都快四点了，看来碰碰车估计玩不了了。所以我和司机说我们好了，你开过来把，他说四十分钟就能到，所以我们赶快往外面走了。本来啤酒广场是有个 12 号缆车上车点的，但是说关掉了。外面的大屏幕又显示说 16.30 才关，可是这也才四点出头啊，反正也来不及吐槽了，赶快就原路返回吧。</p><p>回来，在一个叫 heart spa 的地方，做了个四手按摩。</p><p>晚上，还去买了个榴莲。原价 22k，一开始说给我们 21k，我直接走了，然后他就说 18k 给我们，我说直接 15k，本来觉得还的比较多，他估计不想卖了，没想到他直接就给了，也是离谱，早知道对半砍了。因为担心在酒店里面吃东西会有异味，我们直接狼吞虎咽，一个人两瓣把榴莲吃完了。鑫鑫非常担心被罚钱，所以自己下去一趟把榴莲扔掉了。</p><h1 id="D3-Oct-02"><a href="#D3-Oct-02" class="headerlink" title="D3 Oct 02"></a>D3 Oct 02</h1><p>早上首先去五行山。这个真的是要了命了，首先是 15 号洞。这是一个很深的洞，进去之后，大概在一个通道里面走几十米，就可以到一个大厅。这个大厅很大，有很多分支。在进入的时候，往右走是一个向下的台阶，通往所谓的地狱。同时，这个洞也比较深，往里面走，可以走到一个观音像面前，左边供着应该是中国越南远征军的牌位，右边不知道是啥。绕一圈回来，有个向上的台阶，通往天堂。这个台阶会把你带到一面“墙”跟前。说他是墙，因为真的很陡，一直通到上面，就是外面的天空。不时还有鸟从天空里面飞进来。</p><p>然后就是坐电梯去五行山上。电梯是个透明的电梯，里面非常热，我在里面非常怕这电梯停了，那感觉会热死。终于还是到了五楼，出门，外面凉风习习。出去之后基本就是一条路，路过一些佛像，路就往左边拐了。这个时候出现分叉，往前下是一个寺庙，往左是往上的一段路。我们前面的旅行团是往下走的，我就想往左走。最后，鑫鑫决定去探一探路，结果前面别有洞天。走到一个丁字路口，左边是一个望海阁，可以看到海，不过视线有遮挡。右边是一个石拱门，就好像是山崖上打了一个洞一样。走进去还是一段路，并不是山洞。但是左边会有一个山洞，</p><p>从五行山出来，打车去占婆博物馆，这个博物馆其实就是过了龙头桥，和我们昨天去的那个很没有吃饭欲望的集市隔河相望。这个博物馆我们也是在门口现金买票，然后走几步才能进去。里面大概分了好几个区域，一进去是一些石头的东西，总体特点就是非常生殖崇拜。比如一个叫 Linga Yoni 的东西，解说直接说 Yoni 就是 female organs of generation. 这个展厅都没有空调，很热，不过再往里走，前方是一个两层的展厅。我们出现在 1.5 层的位置，左右两边各有一个坡道可以往 1 层或者 2 层走，其中往 2 层的两个坡道在尽头，各有两个空调。</p><p>从博物馆出来，我们本来是想找一个很有名的吃饭的地方的，不过找到那里，发现这家店已经关门了。吃完饭，我们打算去刚才过来的路上看到的一家很大，装修很漂亮的 highland 咖啡。我们点了他们家有名的莲子啥的。highland 咖啡出来，就直接打车去山茶半岛。</p><p>我们在山茶半岛主要就是看那个寺庙，以及里面的巨大的观音像。车可以直接把我们送到山上，下车的地方离佛像还有点距离，不过那边有一个看海景的平台。</p><p>佛像下面是可以脱鞋进去的，里面是个一层，有个祭坛，可以拜佛。</p><p>从山茶半岛直接打车去 VVIP 按摩，这打车也是离谱，不让我们在路上打，所以我们又得爬回山上，走到停车场再打。这家店比较贵，花了 100 万 vnd，但是确实做的很好，它可以选择到底哪些项目不做。比如我就不做采耳，鑫鑫还不做修面。不过我觉得修面还是挺好的，毕竟可以刮胡子刮脸，我的脸太油了。不过</p><p>我们今天晚上是坐越旅行航空的飞机，这个飞机是真的扯淡，买的时候是 2025 起飞，然后昨天告诉我调整到 2315。然后过了一会飞猪又告诉我调回到 2025 了，但是飞常准显示还是 2315。然后今天又收到短信说调到 2125 了，就扯淡，但是我们还是得 7 点值机。进去之后，搞了个牛肉河粉吃了下，然后我就找到一个可以坐着充电的地方冲了回电。</p><p>晚上住的宾馆 Phoenix Palace Hotel，简直离谱。当时到的时候就已经觉得不对了，司机停在一条一个人都没有的梧桐小路上，两边店面都是黑的，哪有酒店前台的样子？结果就着昏黄的路灯，看到了黑底白字的门牌，不知道的还以为是个苹果代销商小店呢。这酒店都关门了么？我们尝试推了推门，门是开的。进去之后，一个男的从门口的沙发上爬起来，给我们开灯，然后办理入住。我们先坐了一个非常狭窄，最大载重 450 kg 的电梯到六楼，然后又爬到七楼，门一开，感觉坏了。这是一个非常上世纪风格的卧室，有一大两小两张床，其中一张床在空调下面，没法睡。并且头上是一个窗子，这个窗子还不能打开，所以整个屋子实际上是封闭的，并且散发着一股霉味。那个前台打开了一个老式的空调，设定为 16 度。这个空调感觉类似于我家第一个空调，它遥控器上都是用三角来显示功能的。总之，这个空调声音非常大，并且开了一个小时都没有很好的制冷效果。</p><p>半夜醒来，这是真开始冷了。看来这个空调只是慢，但是确实还是有用的。</p><h1 id="D4-Oct-03"><a href="#D4-Oct-03" class="headerlink" title="D4 Oct 03"></a>D4 Oct 03</h1><p>今天是下龙湾一日游，昨天一个叫 Long 的导游已经联系我了。我们需要小走一点到一条路上，当时有一对情侣也在等着。过来了很多辆大巴，终于等到我们的大巴了。那这个大巴也是非常扯的，我们 7.50 就上去了，结果它八点五十才堪堪接完人绕出河内城，幸亏我早上拉了个屎加上没吃东西。我们大概 11.30 到达下龙市，第一站是参观一个珍珠工坊。这里也是离谱，我看一个珍珠项链都是几百块钱，我想几百 rmb 不贵啊，结果特么是美元，那也太离谱了。反正基本是没人买的，所以大家下楼就会车上了。从车上到上船的地方，只要五分钟。在车上的时候我就问了 Long，是把东西放车上，还是放 cruise 上。结果他好像对 cruise 这个词也不是很理解，而且他的发音也不好。反正一开始我 WhatsApp 问他的时候，他说放车上是很 safe 的。不过后面我进一步问的时候，他说船上更安全，因为有监控，把不值钱的东西可以留在车上。</p><p>于是我就把伞扔在车上，然后大喝一口水（后面这口水非常重要）然后就去码头了。码头门那边的人非常多，但我们并没有等好久，而是直接就到了登船口，在那里，我们被分了一人一个紫色手环，然后大家三三两两上船。导游这个时候都不知道去哪里了，我们非常仔细跟着人才能知道自己上那艘船。一上船，就看到午餐已经摆好了，不过在这个之前，我们需要先落座。门口的船长在尝试按照每组多少人分配座位，我们这一桌六个是 2+2+1+1 的，另外一对男的是从南京来的，感觉有点 gay 里 gay 气的。还有一个人英语很好，他和一个外国老头坐在一起，在我们对面，后来知道，他是平安的一个领导了，并且之前在英国留过学。终于大家安顿好了，船出发了，船长扯了一些大家不想听的东西，就开始吃饭了。大家都从座位上起来，然后在中间的取餐区，逆时针转圈，所以非常拥挤。</p><p>晚上把我们放到接我们的地方，我们就先去按摩。去的是 L’essence de la vie 这个店，人均很高，但是是河内第一。进去之后，前台的黄毛小姐姐领我们去二楼，给我们一些猕猴桃干，白色的很奇怪口感的糖果，两杯水。然后我们选项目，这边有什么皇家矩阵按摩，当时还挺想选的，然后我发现少看了一位数，实际上是一千一百多万，等于几千块钱，太离谱了。最后我们就选了一个越式按摩，两个人大概 555。然后就是坐在那边等，要不是我问了下，都不给我们做。结果我一问，立马就说已经准备好了。</p><p>给我们做的两个人感觉还是比较活泼一点的，做的也很标准。和第二天晚上我们做的那个完全不一样。过程中，我们可以通过比手势 1/2/5 分别表示，轻一点、重一点、换技师这样。不过我觉得总体都很舒服，并且每个部位都按到了，就是力度也很到位。</p><h1 id="D5-Oct-04"><a href="#D5-Oct-04" class="headerlink" title="D5 Oct 04"></a>D5 Oct 04</h1><p>今天也没能睡很晚，九点多就退房出门了，鑫鑫起的比我还早一个小时。</p><p>第一站是大教堂。</p><p>我们在一个香薰店躲雨，顺便买了点东西。</p><p>下一站就是去还剑湖。到的时候，雨很大。湖边有一些雨伞棚子，旁边是 four seasons 的贩售亭，我们点了酸奶咖啡，这边酸奶咖啡感觉酸奶像是老酸奶一样。所以你可以选择搅拌起来吃，或者分开吃各种吃法。服务员自己也点了个咖啡，一边工作一边喝，感觉他们确实喜欢吃。</p><p>从还剑湖出来，其实不是很好打车。不过我们还是要去走到换汇的地方，这边汇率比机场好多了，有 3850，不过可惜我们一个人只能换 200 了。</p><p>从换汇的地方出来，我们走了很长一段，路过了法国街，我已经快背不动我的包了。然后我们终于走到了一条大路边，可以打车了。我们现在要去的地方就是购买冰箱贴的地方。车子停到一个法国梧桐路口，然后我们需要寻找那家店。其实司机多过了一个马路，我们往回走了一段，终于找到一个可以进去的巷子，这个巷子里面有一堆咖啡店，此外还有个 craft，我理解应该就是我们要去的地方。不过我们还是先走到了巷子右边一家二楼的咖啡店问问在哪里，咖啡店说在对面。</p><p>冰箱贴旁边的咖啡馆也是米其林，我们点了个荔枝咖啡。他不在菜单上，不过我们说了 lichi 之后店员就反应过来，说 this is not on the menu, but I know that. 然后其实他们把它发音做 lie chi 这样。所以我说 you do have a hidden menu，他说是的。</p><p>从那个小巷子出来，我们打车去 Red Bean Central。他家的风景很好，坐在餐厅里面可以看到河内的景色。竹筒烤牛肉，那个牛肉并不老，沾着里面自带的黑胡椒酱很好吃。最让我觉得好吃的是柚子沙拉，就是我本来就是看到这个觉得应该很好吃点的，但是它比我想象的还好吃。其实它里面应该是加了一些甜味的，吃起来相比酸更甜，但是却给我一种很解渴的感觉，这个柚子虽然是黄的，但是感觉颗粒很大，吃起来很爽口。我们还点了个越南粉，这个就一般。</p><p>吃完饭结完账，发现电梯间往另一个方向走，还可以到一个露台，那个露台上的风景真的是绝了，并且小风吹着很舒服。加上这种上世纪的建筑风格，我感觉我回到了我童年的时光，当时在破旧的图书馆借一点书，到家里看着玩玩，非常开心。</p><p>从餐厅出来，打车去火车市场。刚下车，就有一个粉衣服妇女迎上来，用中文问我要不要去看火车，我不喜欢这种上来就中文的，所以就躲开了。然后进去之后，又遇到一家店铺，然后我才知道下一班火车得是四点十分，可是我们现在才两点十分。剩下来的行程只有一个逛超市了，所以我就决定先去按摩。于是我们打车到了第二名 Orient 这个店。我们本来是想做个 massage 的，但是问了说最早都得晚上六点半，当时准备走了，我想了想，我再问问洗头呗，答复说现在就可以做，于是我们就做了个洗头+洗脸。这个洗头非常舒服，印象深刻的是他有一个环形的管道，可以对你的头冲水，就好像按摩一样，非常舒服。这个洗头服务本身也带有按摩肩颈，但同样也没有很多，比 VVIP 要多一些。</p><p>做完了，赶快打车去刚才的地方，到了的时候还有五分钟，鑫鑫真的是时间管理大师。因为我们来的时候会从北往南经过河内火车站，所以我以为列车也是从河内站始发的（不然我不相信能这么准点），但实际上火车是进河内站的。并且相比 16.10 的预定时间，只是晚点了 7 分钟，可以说很厉害了。</p><p>火车快来的时候，这些店铺老板就开始疯狂赶人了。后来我发现这个真的很有必要，因为火车来的时候，真的和我很接近。我觉得我坐着把手伸出去那应该都能碰到火车。</p><p>火车开走之后，我们把椰子喝完，然后顺着火车离开的方向走到了另一条马路上，然后开始打车前往乐天超市。</p><p>从超市出来，发现旁边就是澳大利亚的大使馆。我们直接在大使馆门口打车，到宾馆。在那里，我们去到了昨天已经关门的 PHO GA NGUYET 河粉店。其实远远地就看到人行道上全是人，想必是这家了。本来以为要排很久准备放弃了，结果这队伍是非常的快，一两分钟之后，我们就已经坐下来了。点餐也很容易，基本就是鸡肉干拌河粉，其他的小配菜其实也没啥意思。上菜还是比较慢的，然后给了一个白纸上写了一个看不懂的鬼画符，就是我们的账单。</p><p>吃完，准备做个按摩就走了，先去了 old quarter 那里，结果直接 fully booked 了。</p><h1 id="D6-Oct-05"><a href="#D6-Oct-05" class="headerlink" title="D6 Oct 05"></a>D6 Oct 05</h1><p>给我们分配了一个安全出口，非常开心了。我感觉可能还是要值机比较早才行。</p>]]></content>
    
    
    <summary type="html">&lt;p&gt;国庆节和鑫鑫去了越南。&lt;/p&gt;</summary>
    
    
    
    
    <category term="游记" scheme="http://www.calvinneo.com/tags/游记/"/>
    
  </entry>
  
  <entry>
    <title>2026 Sep Vibe coding 经验总结</title>
    <link href="http://www.calvinneo.com/2026/09/28/vibe-coding-sep-2026/"/>
    <id>http://www.calvinneo.com/2026/09/28/vibe-coding-sep-2026/</id>
    <published>2026-09-28T14:48:32.000Z</published>
    <updated>2026-10-15T13:53:25.969Z</updated>
    
    <content type="html"><![CDATA[<h1 id="总的体会"><a href="#总的体会" class="headerlink" title="总的体会"></a>总的体会</h1><ul><li>各种 skill、harness 等返璞归真，不太需要了，模型自己有非常强的能力。</li><li>模型自己本身的防御性编程意识非常浓厚，需要进行限制。否则写出来的代码非常啰嗦。</li></ul><a id="more"></a><h1 id="命令"><a href="#命令" class="headerlink" title="命令"></a>命令</h1><h2 id="脚本"><a href="#脚本" class="headerlink" title="脚本"></a>脚本</h2><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br></pre></td><td class="code"><pre><span class="line">在你写脚本的时候，禁止对下列的情况进行防御编程：</span><br><span class="line">1. 同时存在多个测试。</span><br><span class="line">2. 存在没有清理的环境。用户指定一个目录，所有这个脚本产生的副作用，都在这个目录中。如果你启动容器，需要将这个目录挂在到容器中，目的是保留每个容器各自的日志。</span><br><span class="line">3. 因为用户每次都会指定不同的目录来运行脚本，所以在这个目录中写的文件，不需要考虑它的名字可能和来自外部的写入冲突。</span><br><span class="line">4. 对环境进行各种检测，如果你需要检测，请你在写脚本之前就检测。如果你需要进行破坏性的检查，需要请求我的批准。</span><br><span class="line">5. 构建镜像时，对镜像的取名应该体现出用途。禁止设置版本号，每次编译都会覆盖同名镜像。</span><br><span class="line"></span><br><span class="line">你需要将脚本写的足够简练，所以禁止：</span><br><span class="line">1. 将我不关心的东西也设置为变量。如果一个东西在可见的未来并不需要被修改，就 hardcode 它。</span><br><span class="line">2. 用 echo 或者 printf 构造另一个脚本，对于这种情况，你就应该准备另一个脚本，或者封装为一个函数。</span><br><span class="line">3. 你写的脚本最终都会被我执行和验证，所以要写的能让人类看懂。你可以自己在本地进行验证，如果你这么做了，需要把你因为验证编译的镜像和启动的容器全部清理掉。并且你要告诉我你做了什么。</span><br><span class="line">4. 给出的命令，如果可能，以 ~ 相对目录开头。</span><br><span class="line">5. 你需要尽可能减少修改规模，不要尝试隐式修改任何默认值（除非被明确要求这么做）。</span><br><span class="line"></span><br><span class="line">在进行测试时：</span><br><span class="line">1. 如果我提及 ssh 到某个机器中，在某个目录里面修改并测试，那么你就不要修改本地的任何代码，也不要在本地生成任何镜像。</span><br></pre></td></tr></table></figure><h2 id="特性"><a href="#特性" class="headerlink" title="特性"></a>特性</h2><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line">在你写特性的时候，必须做到：</span><br><span class="line">- 写出让人能读懂的、足够简练的代码非常重要。你需要时刻思考是否可以利用既有的假设简化代码。</span><br><span class="line">- 你要用批判式目光看当前的代码，如果有必要的设计、乃至重构，能让代码整体简洁优雅，应当执行。</span><br><span class="line">- 你不应该回避破坏性修改，甚至引入一些复杂的设计去绕过它们。如果你不确定如何修改，可以请求我的批准。</span><br><span class="line">- 增加测试的时候，应该尽可能尝试复用已有的测试基建。</span><br><span class="line">- 我提的一些目标可能是表达不够精确的，可能是因为我缺少一些信息。所以你要判断我真实的意思，如果你认为我表达有偏差，请询问我，而不是死板执行</span><br></pre></td></tr></table></figure><h2 id="汇报"><a href="#汇报" class="headerlink" title="汇报"></a>汇报</h2><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line">在实现功能时，请遵循以下原则：</span><br><span class="line">- 优先保持代码简洁、可读：充分利用已有约定和明确成立的假设，避免不必要的抽象、防御逻辑和特殊分支。</span><br><span class="line">- 主动改进设计：批判性地审视现有代码；如果合理的设计调整或重构能让整体实现更清晰，就应执行，避免只做局部补丁。</span><br><span class="line">- 接受必要的破坏性变更：不要为了维持兼容而引入不必要的复杂性。涉及重要取舍或影响不明确时，说明方案、收益和影响，再向我确认。</span><br><span class="line">- 复用测试基建：优先沿用已有测试工具、辅助方法和组织方式，验证实际行为。</span><br><span class="line">- 以真实目标为准：不要机械执行字面要求。发现关键歧义、错误前提或目标与方案冲突时，指出问题并向我确认；常规实现细节自行判断。</span><br></pre></td></tr></table></figure><h2 id="学习"><a href="#学习" class="headerlink" title="学习"></a>学习</h2><p>见 <a href="https://www.calvinneo.com/about/xzfs/">https://www.calvinneo.com/about/xzfs/</a></p>]]></content>
    
    
    <summary type="html">&lt;h1 id=&quot;总的体会&quot;&gt;&lt;a href=&quot;#总的体会&quot; class=&quot;headerlink&quot; title=&quot;总的体会&quot;&gt;&lt;/a&gt;总的体会&lt;/h1&gt;&lt;ul&gt;
&lt;li&gt;各种 skill、harness 等返璞归真，不太需要了，模型自己有非常强的能力。&lt;/li&gt;
&lt;li&gt;模型自己本身的防御性编程意识非常浓厚，需要进行限制。否则写出来的代码非常啰嗦。&lt;/li&gt;
&lt;/ul&gt;</summary>
    
    
    
    
    <category term="LLM" scheme="http://www.calvinneo.com/tags/LLM/"/>
    
    <category term="agent" scheme="http://www.calvinneo.com/tags/agent/"/>
    
  </entry>
  
  <entry>
    <title>Attention</title>
    <link href="http://www.calvinneo.com/2026/09/23/attention-structures/"/>
    <id>http://www.calvinneo.com/2026/09/23/attention-structures/</id>
    <published>2026-09-23T15:07:22.000Z</published>
    <updated>2026-09-27T03:38:53.477Z</updated>
    
    <content type="html"><![CDATA[<p>本文来自于我和 GPT-6 聊天的总结。</p><p>本文只解释结构：输入从哪里来，模块如何连接，哪些位置能够互相读取，以及推理时保存什么数据。例如<strong>模型里的数据通路</strong>，以及 <strong>GPU 上的计算和缓存组织</strong>。</p><p>覆盖范围以 Transformer 和大语言模型为主，同时补充经典序列模型、视觉、语音和图数据中常见的 Attention 结构。</p><a id="more"></a><h1 id="正文"><a href="#正文" class="headerlink" title="正文"></a>正文</h1>]]></content>
    
    
    <summary type="html">&lt;p&gt;本文来自于我和 GPT-6 聊天的总结。&lt;/p&gt;
&lt;p&gt;本文只解释结构：输入从哪里来，模块如何连接，哪些位置能够互相读取，以及推理时保存什么数据。例如&lt;strong&gt;模型里的数据通路&lt;/strong&gt;，以及 &lt;strong&gt;GPU 上的计算和缓存组织&lt;/strong&gt;。&lt;/p&gt;
&lt;p&gt;覆盖范围以 Transformer 和大语言模型为主，同时补充经典序列模型、视觉、语音和图数据中常见的 Attention 结构。&lt;/p&gt;</summary>
    
    
    
    
    <category term="机器学习" scheme="http://www.calvinneo.com/tags/机器学习/"/>
    
    <category term="AIGen" scheme="http://www.calvinneo.com/tags/AIGen/"/>
    
    <category term="LLM" scheme="http://www.calvinneo.com/tags/LLM/"/>
    
  </entry>
  
  <entry>
    <title>Review on Database paper</title>
    <link href="http://www.calvinneo.com/2026/09/22/database-paper-1-7-review/"/>
    <id>http://www.calvinneo.com/2026/09/22/database-paper-1-7-review/</id>
    <published>2026-09-22T15:22:33.000Z</published>
    <updated>2026-09-29T11:36:26.348Z</updated>
    
    <content type="html"><![CDATA[<p><strong>Database paper part 1–7：对照论文原文的核查报告</strong></p><p>核对日期：2026-09-22。按 7 篇博文组织，覆盖其中 23 篇论文／技术报告及 Titan 工程延伸，共保留 <strong>36 处</strong>值得纠正或澄清的表述。</p><a id="more"></a><h1 id="Database-paper-part-1"><a href="#Database-paper-part-1" class="headerlink" title="Database paper part 1"></a>Database paper part 1</h1><p>博文：<a href="https://www.calvinneo.com/2024/03/08/database-paper-1/">Database paper part 1</a>。</p><h2 id="C-Store-A-Column-oriented-DBMS"><a href="#C-Store-A-Column-oriented-DBMS" class="headerlink" title="C-Store: A Column-oriented DBMS"></a>C-Store: A Column-oriented DBMS</h2><h3 id="1-两类编码的适用条件写反了【明确错误】"><a href="#1-两类编码的适用条件写反了【明确错误】" class="headerlink" title="1. 两类编码的适用条件写反了【明确错误】"></a>1. 两类编码的适用条件写反了【明确错误】</h3><ul><li><strong>博客摘录</strong>：“bitmap”；“delta encoding”。位置：CStore 末尾的 RS 存储优化列表。<strong>上下文转述</strong>：作者把高基数、按本列排序的列对应到位图编码，把低基数、不按本列排序的列对应到差分编码。</li><li><strong>论文摘录</strong>：“Type 2: Foreign-order, few distinct values”；“b is a bitmap”；“Type 3: Self-order, many distinct values”。见 <a href="https://www.vldb.org/conf/2005/papers/p553-stonebraker.pdf#page=5" target="_blank" rel="noopener">论文 §3.1，PDF 第 5 页</a>。</li><li><strong>为什么不对</strong>：论文给低基数、按其他列排序的列建立位图；给高基数、按本列排序的列保存相邻值之差。博客恰好调换了这两项。更正后四种对应关系是：自排序且低基数→游程编码；非自排序且低基数→位图；自排序且高基数→差分；非自排序且高基数→论文暂不编码。</li></ul><h4 id="【Response】"><a href="#【Response】" class="headerlink" title="【Response】"></a>【Response】</h4><p>确实是笔误。</p><h2 id="Kudu-Storage-for-Fast-Analytics-on-Fast-Data"><a href="#Kudu-Storage-for-Fast-Analytics-on-Fast-Data" class="headerlink" title="Kudu: Storage for Fast Analytics on Fast Data"></a>Kudu: Storage for Fast Analytics on Fast Data</h2><h3 id="1-把规划中的-PRE-VOTER-写成了已经采用的机制【论文版本／时态不准确】"><a href="#1-把规划中的-PRE-VOTER-写成了已经采用的机制【论文版本／时态不准确】" class="headerlink" title="1. 把规划中的 PRE_VOTER 写成了已经采用的机制【论文版本／时态不准确】"></a>1. 把规划中的 PRE_VOTER 写成了已经采用的机制【论文版本／时态不准确】</h3><ul><li><strong>博客摘录</strong>：“主要引入了 Pre Voter”。位置：Replication 末尾。</li><li><strong>论文摘录</strong>：“we plan to implement a PRE VOTER replica state”。见 <a href="https://kudu.apache.org/kudu.pdf#page=5" target="_blank" rel="noopener">论文 §3.3.1，PDF 第 5 页</a>。</li><li><strong>为什么欠妥</strong>：所链接论文描述的当时实现会直接把新节点加入为 VOTER；PRE_VOTER 是解决追赶期间可用性下降的计划方案。博客对该方案作用的解释基本正确，但没有区分现有实现与未来设计。</li></ul><h4 id="【Response】-1"><a href="#【Response】-1" class="headerlink" title="【Response】"></a>【Response】</h4><p>这也太会挑刺了。</p><h3 id="2-32-MB-的边界属于-DiskRowSet，不是其内部每个文件【明确错误】"><a href="#2-32-MB-的边界属于-DiskRowSet，不是其内部每个文件【明确错误】" class="headerlink" title="2. 32 MB 的边界属于 DiskRowSet，不是其内部每个文件【明确错误】"></a>2. 32 MB 的边界属于 DiskRowSet，不是其内部每个文件【明确错误】</h3><ul><li><strong>博客摘录</strong>：“32MB 大小的文件”。位置：Tablet storage → DiskRowSet 首段。<strong>上下文转述</strong>：作者称一个 DiskRowSet 被拆成若干个这种大小的文件。</li><li><strong>论文摘录</strong>：“we roll the DiskRowSet after each 32 MB of IO”。见 <a href="https://kudu.apache.org/kudu.pdf#page=7" target="_blank" rel="noopener">论文 §4.4，PDF 第 7 页</a>。</li><li><strong>为什么不对</strong>：这里是在刷新 MemRowSet 时，每累计约 32 MB I/O 就结束当前 DiskRowSet、生成下一个；一个 MemRowSet 因而可以产生多个 DiskRowSet。论文并未规定每个列文件都是 32 MB。博客把 RowSet 的切分粒度误写成了其内部文件大小，容易误解后续增量压缩的单位。</li></ul><h2 id="Cache-Craftiness-for-Fast-Multicore-Key-Value-Storage（Masstree）"><a href="#Cache-Craftiness-for-Fast-Multicore-Key-Value-Storage（Masstree）" class="headerlink" title="Cache Craftiness for Fast Multicore Key-Value Storage（Masstree）"></a>Cache Craftiness for Fast Multicore Key-Value Storage（Masstree）</h2><h3 id="1-border-node-本身就是该层-B-树的叶节点【结构解释错误】"><a href="#1-border-node-本身就是该层-B-树的叶节点【结构解释错误】" class="headerlink" title="1. border node 本身就是该层 B+ 树的叶节点【结构解释错误】"></a>1. border node 本身就是该层 B+ 树的叶节点【结构解释错误】</h3><ul><li><strong>博客摘录</strong>：“leaf nodes”。位置：结构中解释图 1 的段落。<strong>上下文转述</strong>：作者把 border node 描述为组织另一层叶节点的节点，并把图中的五角形理解成叶节点。</li><li><strong>论文摘录</strong>：“Border nodes resemble leaf nodes in conventional B+-trees”。见 <a href="https://pdos.csail.mit.edu/papers/masstree:eurosys12.pdf#page=3" target="_blank" rel="noopener">论文 §4.1，PDF 第 3 页</a>。</li><li><strong>为什么不对</strong>：border node 对应当前 B+ 树的叶层，其槽位保存值或者指向更深 trie 层的指针。不能据图形把它解释成“叶节点上面还有一层 border node”。指向下一层 B+ 树的边，也不等同于同一棵 B+ 树内部从父节点到叶节点的边。</li></ul><h3 id="2-无须递增版本号，依靠的是-value-原子更新，不是-version-对齐【机制解释错误】"><a href="#2-无须递增版本号，依靠的是-value-原子更新，不是-version-对齐【机制解释错误】" class="headerlink" title="2. 无须递增版本号，依靠的是 value 原子更新，不是 version 对齐【机制解释错误】"></a>2. 无须递增版本号，依靠的是 value 原子更新，不是 version 对齐【机制解释错误】</h3><ul><li><strong>博客摘录</strong>：“version 的 alignment”。位置：Writer–reader coordination → Update。</li><li><strong>论文摘录</strong>：“atomically updating values using aligned write instructions”。见 <a href="https://pdos.csail.mit.edu/papers/masstree:eurosys12.pdf#page=5" target="_blank" rel="noopener">论文 §4.6.1，PDF 第 5—6 页</a>。</li><li><strong>为什么不对</strong>：论文保证读者只会读到旧值或新值，因此此类值更新可以省去 border node 的版本号递增。博客把原子写的对象从 value 换成 version，反而无法解释为何 version 可以不变。旧值的延迟回收是另一项要求，由随后讨论的 RCU 机制处理。</li></ul><h2 id="Ceph-A-Scalable-High-Performance-Distributed-File-System"><a href="#Ceph-A-Scalable-High-Performance-Distributed-File-System" class="headerlink" title="Ceph: A Scalable, High-Performance Distributed File System"></a>Ceph: A Scalable, High-Performance Distributed File System</h2><p>本次对照没有发现需要列为明确错误的可靠问题。博客关于先更新其他副本、后更新 primary，以及 ack 与磁盘 commit 分离的叙述，均符合 <a href="https://www.usenix.org/event/osdi06/tech/full_papers/weil/weil.pdf#page=6" target="_blank" rel="noopener">2006 年论文 §5.2—5.3，PDF 第 6—7 页</a>。开头把 PG 和 OSD 写成包含关系虽不严谨，但后文已经准确说明对象→PG→OSD 的映射，不建议把它升级为独立技术错误。</p><h1 id="Database-paper-part-2"><a href="#Database-paper-part-2" class="headerlink" title="Database paper part 2"></a>Database paper part 2</h1><p>博文：<a href="https://www.calvinneo.com/2024/11/01/database-paper-2/">Database paper part 2</a>。</p><h2 id="Greenplum-A-Hybrid-Database-for-Transactional-and-Analytical-Workloads"><a href="#Greenplum-A-Hybrid-Database-for-Transactional-and-Analytical-Workloads" class="headerlink" title="Greenplum: A Hybrid Database for Transactional and Analytical Workloads"></a>Greenplum: A Hybrid Database for Transactional and Analytical Workloads</h2><h3 id="1-把-10-秒采样窗口解释为一条查询的时长【表述欠妥】"><a href="#1-把-10-秒采样窗口解释为一条查询的时长【表述欠妥】" class="headerlink" title="1. 把 10 秒采样窗口解释为一条查询的时长【表述欠妥】"></a>1. 把 10 秒采样窗口解释为一条查询的时长【表述欠妥】</h3><ul><li><strong>博客摘录</strong>：“10s 的查询”。语境转述：作者据此解释引言中的锁开销图。<a href="https://www.calvinneo.com/2024/11/01/database-paper-2/#Greenplum">博客，Intro</a></li><li><strong>论文摘录</strong>：“on a 10-second sample”。位置：§1，论文第 2 页，配套 Figure 2 在第 3 页。<a href="https://arxiv.org/pdf/2103.11080#page=2" target="_blank" rel="noopener">论文</a></li><li><strong>为什么欠妥</strong>：原文讲的是 10 秒的采样窗口，没有把某条查询的延迟设为 10 秒。前后讨论的对象反而是短查询在高并发下受到的锁开销。将采样时长写成查询时长会改变读者对实验负载的理解。宜写成“在 10 秒采样中观察锁时间占比随连接数的变化”。</li></ul><h2 id="Amazon-Aurora-Design-Considerations-for-High-Throughput-Cloud-Native-Relational-Databases"><a href="#Amazon-Aurora-Design-Considerations-for-High-Throughput-Cloud-Native-Relational-Databases" class="headerlink" title="Amazon Aurora: Design Considerations for High Throughput Cloud-Native Relational Databases"></a>Amazon Aurora: Design Considerations for High Throughput Cloud-Native Relational Databases</h2><h3 id="1-消除的是驱逐时的数据页写出，不是缓存驱逐【明确错误】"><a href="#1-消除的是驱逐时的数据页写出，不是缓存驱逐【明确错误】" class="headerlink" title="1. 消除的是驱逐时的数据页写出，不是缓存驱逐【明确错误】"></a>1. 消除的是驱逐时的数据页写出，不是缓存驱逐【明确错误】</h3><ul><li><strong>博客摘录</strong>：“cache evection”。语境转述：作者把它与后台写、checkpoint 一起列为 Aurora 数据库层没有的机制。<a href="https://www.calvinneo.com/2024/11/01/database-paper-2/#Offloading-Redo-Processing-to-Storage">博客，Offloading Redo Processing to Storage</a></li><li><strong>论文摘录</strong>：“the system finds a victim page to evict”。位置：§4.2.3，论文印刷页 1046／PDF 第 6 页。<a href="https://cdn.amazon.science/dc/2b/4ef2b89649f9a393d37d3e042f4e/amazon-aurora-design-considerations-for-high-throughput-cloud-native-relational-databases.pdf#page=6" target="_blank" rel="noopener">论文</a></li><li><strong>为什么不对</strong>：缓存容量有限，Aurora 仍会选择并驱逐页面。变化在于驱逐脏页时不由数据库实例把整页写回存储，因为修改已经通过 redo 日志交给存储层。这是删除 page flush 路径，不是删除 eviction。博客后文也继续讨论驱逐，说明这里应收窄用语。</li></ul><h3 id="2-“重启无操作”必须限定为不再集中回放-redo【表述欠妥】"><a href="#2-“重启无操作”必须限定为不再集中回放-redo【表述欠妥】" class="headerlink" title="2. “重启无操作”必须限定为不再集中回放 redo【表述欠妥】"></a>2. “重启无操作”必须限定为不再集中回放 redo【表述欠妥】</h3><ul><li><strong>博客摘录</strong>：“无需进行任何的操作”。语境转述：作者在说明 redo 下推后，将其作为数据库重启时的总体结论。<a href="https://www.calvinneo.com/2024/11/01/database-paper-2/#Offloading-Redo-Processing-to-Storage">博客，同一节</a></li><li><strong>论文摘录</strong>：“The database does need to reestablish its runtime state”。位置：§4.3，印刷页 1046；后续 undo 说明在 1047。<a href="https://cdn.amazon.science/dc/2b/4ef2b89649f9a393d37d3e042f4e/amazon-aurora-design-considerations-for-high-throughput-cloud-native-relational-databases.pdf#page=6" target="_blank" rel="noopener">论文</a></li><li><strong>为什么欠妥</strong>：启动仍需与每个 PG 的读 quorum 交互、重新确定 VDL、持久记录截断范围，并重建未完成事务信息，随后执行可在线进行的 undo。被消除的是传统数据库启动前集中回放 redo 的工作。论文 §3.2 本身也用了概括性的“启动无需工作”的说法，因此这不是纯粹翻译错误；但结合 §4.3，博客应明确其适用范围。</li></ul><p><strong>核验备注（不计为博客误读）</strong>：博客给出的页面驱逐条件 <code>pageLSN ≥ VDL</code> 与 §4.2.3 原文一致；按前文 VDL 的持久前缀定义，以及本段要求页面所有修改已持久化的语义推导，应为 <code>pageLSN ≤ VDL</code>。这是论文内部的疑似不等号笔误，不计为博客误读。<a href="https://cdn.amazon.science/dc/2b/4ef2b89649f9a393d37d3e042f4e/amazon-aurora-design-considerations-for-high-throughput-cloud-native-relational-databases.pdf#page=6" target="_blank" rel="noopener">同页原文</a></p><h2 id="Dynamo-Amazon’s-Highly-Available-Key-value-Store"><a href="#Dynamo-Amazon’s-Highly-Available-Key-value-Store" class="headerlink" title="Dynamo: Amazon’s Highly Available Key-value Store"></a>Dynamo: Amazon’s Highly Available Key-value Store</h2><h3 id="1-Merkle-树叶子散列的是-value，不是只有-key【明确错误】"><a href="#1-Merkle-树叶子散列的是-value，不是只有-key【明确错误】" class="headerlink" title="1. Merkle 树叶子散列的是 value，不是只有 key【明确错误】"></a>1. Merkle 树叶子散列的是 value，不是只有 key【明确错误】</h3><ul><li><strong>博客摘录</strong>：“key 的哈希值”。语境转述：作者用它定义 Merkle 树的叶子。<a href="https://www.calvinneo.com/2024/11/01/database-paper-2/#Handling-permanent-failures-Replica-synchronization">博客，Handling permanent failures: Replica synchronization</a></li><li><strong>论文摘录</strong>：“hashes of the values of individual keys”。位置：§4.7，PDF 第 8 页。<a href="https://www.allthingsdistributed.com/files/amazon-dynamo-sosp2007.pdf#page=8" target="_blank" rel="noopener">论文</a></li><li><strong>为什么不对</strong>：副本同步要检测同一个 key 的内容是否不同。如果 A 保存 <code>k→v1</code>、B 保存 <code>k→v2</code>，只对 key 做哈希，两边叶子会相同，树根也无法反映这次内容差异。论文要求对各 key 对应的 value 做哈希，再向上汇总，才能识别这种副本分歧。</li></ul><p><strong>核验备注</strong>：博客关于 hinted handoff 避免临时故障导致请求失败的概括，基本复述论文 §4.6，不能当作独立的误读证据；严格理解仍需结合 §4.5 的 R/W 响应门槛。博客的向量时钟单向比较表述也近乎逐字对应原文，本次也未将其列为博客独立错误。</p><h2 id="WiscKey-Separating-Keys-from-Values-in-SSD-Conscious-Storage"><a href="#WiscKey-Separating-Keys-from-Values-in-SSD-Conscious-Storage" class="headerlink" title="WiscKey: Separating Keys from Values in SSD-Conscious Storage"></a>WiscKey: Separating Keys from Values in SSD-Conscious Storage</h2><p>对照版本：TOS 2017 扩展版。<a href="https://research.cs.wisc.edu/adsl/Publications/tos17-lu.pdf" target="_blank" rel="noopener">作者提供的论文全文</a></p><h3 id="1-恢复扫描的终点写反了【明确错误】"><a href="#1-恢复扫描的终点写反了【明确错误】" class="headerlink" title="1. 恢复扫描的终点写反了【明确错误】"></a>1. 恢复扫描的终点写反了【明确错误】</h3><ul><li><strong>博客摘录</strong>：“直到 tail”。语境转述：作者说恢复时从最近持久保存的 head 扫描到该处。<a href="https://www.calvinneo.com/2024/11/01/database-paper-2/#Optimizing-the-LSM-Tree-Log">博客，Optimizing the LSM-Tree Log</a></li><li><strong>论文摘录</strong>：“until the end of the vLog”。位置：§3.4.2，页码 5:14／PDF 第 14 页。<a href="https://research.cs.wisc.edu/adsl/Publications/tos17-lu.pdf#page=14" target="_blank" rel="noopener">论文</a></li><li><strong>为什么不对</strong>：tail 是旧数据一端的 GC 边界；head 是追加位置，持久保存的 head 相当于恢复扫描的起点。恢复应从这个检查点继续向文件末尾扫描，以重建尚未进入持久 LSM 的新记录。扫描到 tail 混淆了恢复与 GC 的方向，不能找回检查点之后追加的数据。</li></ul><h2 id="Titan（工程延伸）"><a href="#Titan（工程延伸）" class="headerlink" title="Titan（工程延伸）"></a>Titan（工程延伸）</h2><p>该节主要是对 <a href="https://docs.pingcap.com/zh/tidb/stable/titan-overview/" target="_blank" rel="noopener">TiDB 官方 Titan 文档</a>的工程说明，博文未指定一篇独立的 Titan 论文。已核对其 KV 分离、BlobFile、传统 GC 与 Level Merge 概述，未发现适合按“博客—论文原文”格式列出的可靠问题；不把 WiscKey 的恢复算法直接当成 Titan 的实现规范。</p><h1 id="Database-paper-part-3"><a href="#Database-paper-part-3" class="headerlink" title="Database paper part 3"></a>Database paper part 3</h1><p>博客：<a href="https://www.calvinneo.com/2024/11/10/database-paper-3/">Database paper part 3</a>。</p><h2 id="DuckDB-an-Embeddable-Analytical-Database"><a href="#DuckDB-an-Embeddable-Analytical-Database" class="headerlink" title="DuckDB: an Embeddable Analytical Database"></a>DuckDB: an Embeddable Analytical Database</h2><h3 id="1-把避免崩溃的设计要求写成崩溃后的隔离保证【表述欠妥】"><a href="#1-把避免崩溃的设计要求写成崩溃后的隔离保证【表述欠妥】" class="headerlink" title="1. 把避免崩溃的设计要求写成崩溃后的隔离保证【表述欠妥】"></a>1. 把避免崩溃的设计要求写成崩溃后的隔离保证【表述欠妥】</h3><ul><li><strong>博客摘录</strong>：“不会把宿主程序给崩掉”。上下文转述：作者说内嵌数据库即使已经崩溃，例如 OOM，也不会使宿主程序崩溃，而是终止查询。（博客 DuckDB / Intro / 稳定性。）</li><li><strong>论文摘录</strong>：“it takes the host down with it.”；“Queries need to be able to be aborted cleanly”。<a href="https://mytherin.github.io/papers/2019-duckdbdemo.pdf#page=2" target="_blank" rel="noopener">原文 §1，PDF 第 2 页</a></li><li><strong>为什么欠妥</strong>：论文恰恰先指出，同一进程内的嵌入式数据库一旦崩溃会连带宿主，然后据此提出资源不足时应可控地中止查询的要求。查询报错并正常返回与数据库已经崩溃是两件事。博客把前者的设计目标写成后者的故障隔离保证；原论文没有说数据库或进程真的崩溃后宿主仍能存活。</li></ul><h2 id="Bitcask-A-Log-Structured-Hash-Table-for-Fast-Key-Value-Data"><a href="#Bitcask-A-Log-Structured-Hash-Table-for-Fast-Key-Value-Data" class="headerlink" title="Bitcask: A Log-Structured Hash Table for Fast Key/Value Data"></a>Bitcask: A Log-Structured Hash Table for Fast Key/Value Data</h2><p><strong>未发现足以列为确定错误的问题。</strong> 博客实际链接的是二手技术文章；本次另查 <a href="https://riak.com/assets/bitcask-intro.pdf" target="_blank" rel="noopener">Basho 原始技术报告</a>。其关于 active file、内存 keydir、merge、hint file 和操作系统缓存的主要说明与原报告相符。对扫描负载和内存攒批的评价缺乏充分论证，但措辞存在解释空间，不据此硬判错误。</p><h2 id="Alibaba-Hologres-A-Cloud-Native-Service-for-Hybrid-Serving-Analytical-Processing"><a href="#Alibaba-Hologres-A-Cloud-Native-Service-for-Hybrid-Serving-Analytical-Processing" class="headerlink" title="Alibaba Hologres: A Cloud-Native Service for Hybrid Serving/Analytical Processing"></a>Alibaba Hologres: A Cloud-Native Service for Hybrid Serving/Analytical Processing</h2><h3 id="1-整个-shard-file-可见的条件把最大值写成最小值【明确错误】"><a href="#1-整个-shard-file-可见的条件把最大值写成最小值【明确错误】" class="headerlink" title="1. 整个 shard file 可见的条件把最大值写成最小值【明确错误】"></a>1. 整个 shard file 可见的条件把最大值写成最小值【明确错误】</h3><ul><li><strong>博客摘录</strong>：“minimum LSN”。上下文转述：作者把这个值不大于读版本作为整个文件可见的条件。（博客 Hologres 列存读取的第 2 个条件。）</li><li><strong>论文摘录</strong>：“if its maximum LSN is equal to or smaller than LSNread”。<a href="https://www.vldb.org/pvldb/vol13/p3272-jiang.pdf#page=6" target="_blank" rel="noopener">原文 §3.4，PDF 第 6 页，印刷页 3277</a></li><li><strong>为什么不对</strong>：必须检查文件的 <strong>最大</strong> LSN，而不是最小 LSN。例如文件含 LSN 10 和 30，读取版本为 20，最小值虽然小于 20，LSN 30 的行仍不能被读到。博客条件会把部分可见文件误判成全部可见，也使紧随其后的第三种情况无法正常成立。应为：最小值大于读版本则跳过；最大值不大于读版本则全部可见；其他情况逐行过滤。</li></ul><h3 id="2-suspended-状态的可调度性写反了【明确错误，可能是漏字】"><a href="#2-suspended-状态的可调度性写反了【明确错误，可能是漏字】" class="headerlink" title="2. suspended 状态的可调度性写反了【明确错误，可能是漏字】"></a>2. suspended 状态的可调度性写反了【明确错误，可能是漏字】</h3><ul><li><strong>博客摘录</strong>：“被调度”。上下文转述：作者用这个词解释任务队列为空时的 suspended 状态。（博客 Execution Context 生命周期段。）</li><li><strong>论文摘录</strong>：“Being suspended means the EC cannot be scheduled”。<a href="https://www.vldb.org/pvldb/vol13/p3272-jiang.pdf#page=7" target="_blank" rel="noopener">原文 §4.2.2，PDF 第 7 页，印刷页 3278</a></li><li><strong>为什么不对</strong>：队列为空时没有任务可执行，EC 不可被调度；有任务提交后才切换为 runnable。博客很可能漏了否定词，但按现有文字理解会直接颠倒调度状态机。</li></ul><h2 id="CockroachDB-The-Resilient-Geo-Distributed-SQL-Database"><a href="#CockroachDB-The-Resilient-Geo-Distributed-SQL-Database" class="headerlink" title="CockroachDB: The Resilient Geo-Distributed SQL Database"></a>CockroachDB: The Resilient Geo-Distributed SQL Database</h2><h3 id="1-节点心跳的方向和两类租约被混在一起【明确错误】"><a href="#1-节点心跳的方向和两类租约被混在一起【明确错误】" class="headerlink" title="1. 节点心跳的方向和两类租约被混在一起【明确错误】"></a>1. 节点心跳的方向和两类租约被混在一起【明确错误】</h3><ul><li><strong>博客摘录</strong>：“从 system Range 往”。上下文转述：作者说由 system Range 向各 Range 的 leaseholder 维持 4.5 秒心跳，并笼统说 lease 每 9 秒续期。（博客 SYSTEM OVERVIEW。）</li><li><strong>论文摘录</strong>：“nodes heartbeat”；“System Ranges”。<a href="https://www.cockroachlabs.com/pdf/cockroachdb-the-resilient-geo-distributed-sql-database-sigmod-2020.pdf#page=3" target="_blank" rel="noopener">原文 §2.2.1，PDF 第 3 页，印刷页 1495</a></li><li><strong>为什么不对</strong>：原论文描述的是节点每 4.5 秒更新 system Range 中的存活记录，用户 Range 的 lease 绑定其所在节点的存活性。每 9 秒更新的是 system Range 自己采用的到期型租约。博客既反转心跳方向，也省掉 9 秒续期所针对的租约种类，容易被理解成所有 Range 租约都按同一固定到期机制运行。</li></ul><h3 id="2-写写冲突不一定要求重试事务【概括过度；作者以问答补充】"><a href="#2-写写冲突不一定要求重试事务【概括过度；作者以问答补充】" class="headerlink" title="2. 写写冲突不一定要求重试事务【概括过度；作者以问答补充】"></a>2. 写写冲突不一定要求重试事务【概括过度；作者以问答补充】</h3><ul><li><strong>博客摘录</strong>：“重试”。上下文转述：作者在问号标注的补充中，将 WW 冲突概括为一定需要重试。（博客解释 leaseholder 算法的问答补充。）</li><li><strong>论文摘录</strong>：“will wait”；“advances its timestamp”。<a href="https://www.cockroachlabs.com/pdf/cockroachdb-the-resilient-geo-distributed-sql-database-sigmod-2020.pdf#page=6" target="_blank" rel="noopener">原文 §3.3.3，PDF 第 6 页，印刷页 1498</a></li><li><strong>为什么不对</strong>：论文区分两种情况：遇到较早事务尚未提交的 intent，等待该事务结束；遇到时间戳更高的已提交值，把自己的时间戳向后推进。时间戳推进后若读集验证成功，事务可以继续。发生死锁或读集失效等情况才可能必须中止或重试。博客后文实际上也正确介绍了等待，不能在前面一概断言必须重试。</li></ul><h3 id="3-closed-timestamp-相对当前时间的方向写反【表述方向有歧义】"><a href="#3-closed-timestamp-相对当前时间的方向写反【表述方向有歧义】" class="headerlink" title="3. closed timestamp 相对当前时间的方向写反【表述方向有歧义】"></a>3. closed timestamp 相对当前时间的方向写反【表述方向有歧义】</h3><ul><li><strong>博客摘录</strong>：“晚 2s”。上下文转述：作者称 closed timestamp 通常比当前时间晚约两秒。（博客 Follower reads。）</li><li><strong>论文摘录</strong>：“trail current time by ~2 seconds”。<a href="https://www.cockroachlabs.com/pdf/cockroachdb-the-resilient-geo-distributed-sql-database-sigmod-2020.pdf#page=7" target="_blank" rel="noopener">原文 §3.5，PDF 第 7 页，印刷页 1499</a></li><li><strong>为什么不对</strong>：原意是落后于当前时间，即时间戳数值约为当前时间减两秒，而不是处于当前时间之后。这也解释了为什么该机制服务的是足够旧的历史快照。若作者用“晚”意指时钟走慢，则应改成“早于当前时间约两秒”消除歧义。</li></ul><p><strong>核验备注（不计为博客独立错误）</strong>：博客在 Algorithm 1 的说明中把 read refresh 写成检查 <code>op.key</code>，随后又写到了整个读集。原论文伪代码第 11 行本身也采用这个简写，正文 §3.1.1、§3.4 才说明验证先前读取的有效性。因此不能把论文自身的简写归咎于博客；实现时应以完整读集验证的说明为准。<a href="https://www.cockroachlabs.com/pdf/cockroachdb-the-resilient-geo-distributed-sql-database-sigmod-2020.pdf#page=4" target="_blank" rel="noopener">原文 Algorithm 1，PDF 第 4 页</a></p><h1 id="Database-paper-part-4"><a href="#Database-paper-part-4" class="headerlink" title="Database paper part 4"></a>Database paper part 4</h1><p>博客：<a href="https://www.calvinneo.com/2024/11/13/database-paper-4/">Database paper part 4</a>。</p><h2 id="Column-Stores-vs-Row-Stores-How-Different-Are-They-Really"><a href="#Column-Stores-vs-Row-Stores-How-Different-Are-They-Really" class="headerlink" title="Column-Stores vs. Row-Stores: How Different Are They Really?"></a>Column-Stores vs. Row-Stores: How Different Are They Really?</h2><h3 id="1-index-only-plan-的性能问题不是回表【明确错误】"><a href="#1-index-only-plan-的性能问题不是回表【明确错误】" class="headerlink" title="1. index-only plan 的性能问题不是回表【明确错误】"></a>1. index-only plan 的性能问题不是回表【明确错误】</h3><ul><li><strong>博客摘录</strong>：“要回表”。上下文转述：作者认为没有过滤条件的列在 index-only plan 中比较慢，是因为需要回表。（博客 ROW-ORIENTED EXECUTION / Index-only plans 的问答。）</li><li><strong>论文摘录</strong>：“Such plans never access the actual tuples on disk.”。<a href="https://15721.courses.cs.cmu.edu/spring2016/papers/p967-abadi.pdf#page=4" target="_blank" rel="noopener">原文 §4，PDF 第 4 页，印刷页 970</a></li><li><strong>为什么不对</strong>：这里的执行计划始终从索引获取列值，无须按照行号去基础表取完整记录。没有谓词的列之所以可能很慢，是需要完整扫描该列索引，再与其他索引得到的行号集合进行合并。例如筛选年龄后求平均薪水，独立薪水索引仍要完整扫描；复合索引则可以直接提供符合年龄条件的薪水。把完整索引扫描误读成回表，混淆了两种不同开销，也与博客自己前一段对 index-only 的定义相矛盾。</li></ul><h2 id="To-BLOB-or-Not-To-BLOB-Large-Object-Storage-in-a-Database-or-a-Filesystem"><a href="#To-BLOB-or-Not-To-BLOB-Large-Object-Storage-in-a-Database-or-a-Filesystem" class="headerlink" title="To BLOB or Not To BLOB: Large Object Storage in a Database or a Filesystem?"></a>To BLOB or Not To BLOB: Large Object Storage in a Database or a Filesystem?</h2><h3 id="1-文中的-GFS-正是-Google-File-System【明确错误】"><a href="#1-文中的-GFS-正是-Google-File-System【明确错误】" class="headerlink" title="1. 文中的 GFS 正是 Google File System【明确错误】"></a>1. 文中的 GFS 正是 Google File System【明确错误】</h3><ul><li><strong>博客摘录</strong>：“不是 Google FS”。（博客 Prior Work / Data layout mechanisms。）</li><li><strong>论文摘录</strong>：“The Google File System.”。<a href="https://www.microsoft.com/en-us/research/wp-content/uploads/2006/04/tr-2006-45.pdf#page=11" target="_blank" rel="noopener">原文 §3.3 引用 Ghemawat，参考文献在 PDF 第 11 页</a></li><li><strong>为什么不对</strong>：正文的 GFS 带有 Ghemawat 文献标记，文末直接给出论文全名及 SOSP 2003 出处，因此系统身份没有歧义。博客紧随其后的 64 MB chunk、并发 record append、记录不跨 chunk 等介绍，也都是在讲这个系统。</li></ul><h3 id="2-75-是旧版碎片整理工具遇到困难的条件，不是自动启动条件【明确错误】"><a href="#2-75-是旧版碎片整理工具遇到困难的条件，不是自动启动条件【明确错误】" class="headerlink" title="2. 75% 是旧版碎片整理工具遇到困难的条件，不是自动启动条件【明确错误】"></a>2. 75% 是旧版碎片整理工具遇到困难的条件，不是自动启动条件【明确错误】</h3><ul><li><strong>博客摘录</strong>：“在跑了”。上下文转述：作者说 NTFS 在磁盘占用超过 75% 时会运行碎片整理机制。（博客同上。）</li><li><strong>论文摘录</strong>：“have difficulties running when the occupancy was greater than 75%”。<a href="https://www.microsoft.com/en-us/research/wp-content/uploads/2006/04/tr-2006-45.pdf#page=5" target="_blank" rel="noopener">原文 §3.3，PDF 第 5 页</a></li><li><strong>为什么不对</strong>：论文说的是 NT 4.0 自带的碎片整理工具在磁盘占用超过该阈值时难以运行，并且紧接着说明后续版本修正了这一限制。博客将工具运行受限的条件写成了整理动作的触发条件，还省略了版本范围。原文不能支持 NTFS 到 75% 就自动执行碎片整理的结论。</li></ul><h3 id="3-storage-age-应明确排除初始装载【表述欠妥；原文定义也不够统一】"><a href="#3-storage-age-应明确排除初始装载【表述欠妥；原文定义也不够统一】" class="headerlink" title="3. storage age 应明确排除初始装载【表述欠妥；原文定义也不够统一】"></a>3. storage age 应明确排除初始装载【表述欠妥；原文定义也不够统一】</h3><ul><li><strong>博客摘录</strong>：“曾经写入”。上下文转述：作者用这个量除以当前仍在使用的数据量，作为 storage age。（博客 Comparing Files and BLOBs / Storage age。）</li><li><strong>论文摘录</strong>：“bytes in deleted or replaced objects”。<a href="https://www.microsoft.com/en-us/research/wp-content/uploads/2006/04/tr-2006-45.pdf#page=2" target="_blank" rel="noopener">原文 Abstract，PDF 第 2 页；实验基准另见 §5.2，PDF 第 8 页</a></li><li><strong>为什么欠妥</strong>：如果将“曾经写入”按字面理解成包括初始装载及目前仍存活的数据，总写入量除以存活量在刚装载完时至少为 1；论文实验却把刚装载完定义为 age 0。更清楚的表述是：统计累计被删除或替换的对象字节数，再除以当前存活对象字节数；实验中这相当于平均覆盖轮数。论文 §4.6 自己也用了“once existed”这种不够明确的措辞，博客并非凭空引入歧义。博客摘要和后文也知道 bulk load 对应 0，因此这里应澄清计数起点，不宜定为独立的概念性误读。<a href="https://www.microsoft.com/en-us/research/wp-content/uploads/2006/04/tr-2006-45.pdf#page=7" target="_blank" rel="noopener">论文 §4.6，PDF 第 7 页</a></li></ul><h2 id="Cloud-Programming-Simplified-A-Berkeley-View-on-Serverless-Computing"><a href="#Cloud-Programming-Simplified-A-Berkeley-View-on-Serverless-Computing" class="headerlink" title="Cloud Programming Simplified: A Berkeley View on Serverless Computing"></a>Cloud Programming Simplified: A Berkeley View on Serverless Computing</h2><h3 id="1-warm-pool-中的虚拟机是待分配，而不是已分配给租户【明确错误】"><a href="#1-warm-pool-中的虚拟机是待分配，而不是已分配给租户【明确错误】" class="headerlink" title="1. warm pool 中的虚拟机是待分配，而不是已分配给租户【明确错误】"></a>1. warm pool 中的虚拟机是待分配，而不是已分配给租户【明确错误】</h3><ul><li><strong>博客摘录</strong>：“被分配给了”。上下文转述：warm pool 中的 VM 被描述为已经分配给某个租户。（博客 Contextualizing Serverless Computing / 隔离。）</li><li><strong>论文摘录</strong>：“need only be assigned to a tenant”。<a href="https://arxiv.org/pdf/1902.03383#page=7" target="_blank" rel="noopener">原文 §2.1，PDF 第 7 页</a></li><li><strong>为什么不对</strong>：这里的意思是启动等准备工作已经完成，接下来只需分配给租户，省掉现建虚拟机的成本。它不是说这些实例已经绑定某个租户。原文还在 §4.2 描述了预先启动操作系统和常用库，使准备好的实例池可供不同租户取用；active pool 则是已经执行过函数、保留以供后续调用的实例。博客把待执行的分配动作误译成已完成状态。</li></ul><h3 id="2-共享内存存储的统计复用，不等于超卖，也不要求把计算合到同一台-VM【表述欠妥】"><a href="#2-共享内存存储的统计复用，不等于超卖，也不要求把计算合到同一台-VM【表述欠妥】" class="headerlink" title="2. 共享内存存储的统计复用，不等于超卖，也不要求把计算合到同一台 VM【表述欠妥】"></a>2. 共享内存存储的统计复用，不等于超卖，也不要求把计算合到同一台 VM【表述欠妥】</h3><ul><li><strong>博客摘录</strong>：“超卖”；“一个 vm 上”。上下文转述：作者用前者概括内存统计复用，又把单个应用受益解释为原先分布于不同 VM 的服务现在可以放到同一 VM。（博客 System challenges / 高性能存储。）</li><li><strong>论文摘录</strong>：“a shared in-memory service”；“another VM belonging to the same application”。<a href="https://arxiv.org/pdf/1902.03383#page=16" target="_blank" rel="noopener">原文 §4.2，PDF 第 16 页</a></li><li><strong>为什么欠妥</strong>：论文此处讨论的是把应用状态放到共享的分布式内存存储里，从而让不同应用、或同一应用在不同 VM 上的函数，按需使用同一存储容量池。计算可以继续位于不同 VM。这个收益来自取消各 VM 对存储容量的固定切分；既不要求承诺容量超过物理容量，也不依赖把函数部署到同一 VM。超卖和计算共置可以是其他资源优化措施，但不是本段正在解释的机制。</li></ul><h1 id="Database-paper-part-5"><a href="#Database-paper-part-5" class="headerlink" title="Database paper part 5"></a>Database paper part 5</h1><p>博文：<a href="https://www.calvinneo.com/2024/11/23/database-paper-5/">Database paper part 5</a>。</p><h2 id="Fast-Scans-on-Key-Value-Stores"><a href="#Fast-Scans-on-Key-Value-Stores" class="headerlink" title="Fast Scans on Key-Value Stores"></a>Fast Scans on Key-Value Stores</h2><h3 id="1-将扫描性能不足概括为只有点查能力【表述欠妥】"><a href="#1-将扫描性能不足概括为只有点查能力【表述欠妥】" class="headerlink" title="1. 将扫描性能不足概括为只有点查能力【表述欠妥】"></a>1. 将扫描性能不足概括为只有点查能力【表述欠妥】</h3><ul><li><strong>博客摘录</strong>：“只支持点查”。语境转述：作者在 Why is it Difficult? 中把 Cassandra、HBase 等 KVS 归入这一类。<a href="https://www.calvinneo.com/2024/11/23/database-paper-5/#Why-is-it-Difficult">博客</a></li><li><strong>论文摘录</strong>：“have difficulties to process scans with a competitive performance”。位置：§8，印刷页 1536／PDF 第 11 页。<a href="https://www.vldb.org/pvldb/vol10/p1526-bocksrocker.pdf#page=11" target="_blank" rel="noopener">论文</a></li><li><strong>为什么欠妥</strong>：论文讨论的是扫描性能不能满足分析负载，而非这些系统没有扫描能力。Table 1 已测出 Cassandra 和 HBase 的扫描耗时，§8 还明确提及 Cassandra 的扫描功能。这里应写成“设计和优化主要面向 get/put，分析扫描性能不足”。§2.2 原文也有将其设计目标概括为只服务 get/put 的宽泛措辞，因此这是未结合全文补充范围，而非博客凭空编造了一个结论。</li></ul><p><strong>核验结论</strong>：其余关于 TellStore-Log／TellStore-Col 的主要数据布局、版本链、self-contained metadata 和 GC 流程，未找到足够可靠的独立误读。博客中若干过于概括的并发与 MVCC 表述，在论文原文中同样存在，不按博客特有错误累计。</p><h2 id="PebblesDB-Building-Key-Value-Stores-using-Fragmented-Log-Structured-Merge-Trees"><a href="#PebblesDB-Building-Key-Value-Stores-using-Fragmented-Log-Structured-Merge-Trees" class="headerlink" title="PebblesDB: Building Key-Value Stores using Fragmented Log-Structured Merge Trees"></a>PebblesDB: Building Key-Value Stores using Fragmented Log-Structured Merge Trees</h2><h3 id="1-把降低内存开销列为收益，与实验结果不符【明确错误】"><a href="#1-把降低内存开销列为收益，与实验结果不符【明确错误】" class="headerlink" title="1. 把降低内存开销列为收益，与实验结果不符【明确错误】"></a>1. 把降低内存开销列为收益，与实验结果不符【明确错误】</h3><ul><li><strong>博客摘录</strong>：“内存开销”。语境转述：摘要将降低它与降低写放大并列为 FLSM 的目标／收益。<a href="https://www.calvinneo.com/2024/11/23/database-paper-5/#PebblesDB">博客，摘要</a></li><li><strong>论文摘录</strong>：“PebblesDb consumes about 300 MB more than HyperLevelDB.” 位置：§5.5、Table 4，PDF 第 15 页。<a href="https://www.cs.utexas.edu/~vijay/papers/sosp17-pebblesdb.pdf#page=15" target="_blank" rel="noopener">论文</a></li><li><strong>为什么不对</strong>：论文的核心收益是减少写 I/O，并未证明普遍节省内存；其实现为 Bloom filter 的保存与构建额外使用内存。Table 4 中，PebblesDB 的读负载内存为 500 MB，HyperLevelDB 为 154 MB，RocksDB 为 36 MB。即使写负载下 PebblesDB 比 RocksDB 占用更少，也不能概括为相对 LSM 普遍降低内存开销。应明确比较对象与负载，并说明空间成本的权衡。</li></ul><h3 id="2-guard-的异步插入被写成并行处理【术语不准确】"><a href="#2-guard-的异步插入被写成并行处理【术语不准确】" class="headerlink" title="2. guard 的异步插入被写成并行处理【术语不准确】"></a>2. guard 的异步插入被写成并行处理【术语不准确】</h3><ul><li><strong>博客摘录</strong>：“并行的”。语境转述：作者以此总结 Inserting and Deleting Guards 的延后插入方案。<a href="https://www.calvinneo.com/2024/11/23/database-paper-5/#Inserting-and-Deleting-Guards">博客</a></li><li><strong>论文摘录</strong>：“guards are inserted asynchronously into FLSM”。位置：§3.3，PDF 第 5 页。<a href="https://www.cs.utexas.edu/~vijay/papers/sosp17-pebblesdb.pdf#page=5" target="_blank" rel="noopener">论文</a></li><li><strong>为什么不对</strong>：这里强调将 guard 先记为 uncommitted，到后续 compaction 再调整 SST 并发布新 guard，避免立即承担跨层改动成本；异步描述任务何时生效，并不意味着这些层同时并行执行。论文另在 §3.4 讨论不同 guard 的 compaction 可以并行，这是另一件事。博客随后对 uncommitted 集合和生效时机的说明基本正确，替换这个术语即可。</li></ul><p><strong>核验备注（不计为独立误读）</strong>：博客关于 compaction 通常不重写 SST 的说法，直接对应 §3.4 原文；作者还主动质疑分割是否需要重写。结合 §3、§3.7，应理解为避免重写目标层已有数据，每份数据通常每层写一次，而非整个 compaction 零写入。博客前面的摘要和 Guards 节已经提到同层限制，因此不宜再把这一句孤立为确定错误。</p><h2 id="The-Snowflake-Elastic-Data-Warehouse"><a href="#The-Snowflake-Elastic-Data-Warehouse" class="headerlink" title="The Snowflake Elastic Data Warehouse"></a>The Snowflake Elastic Data Warehouse</h2><h3 id="1-一致性哈希的对象是表文件名，不是-table-id【明确错误】"><a href="#1-一致性哈希的对象是表文件名，不是-table-id【明确错误】" class="headerlink" title="1. 一致性哈希的对象是表文件名，不是 table id【明确错误】"></a>1. 一致性哈希的对象是表文件名，不是 table id【明确错误】</h3><ul><li><strong>博客摘录</strong>：“table id”。语境转述：在 Local Caching and File Stealing 一节，作者说按表的标识做一致性哈希，使访问同一张表的查询集中到同一 worker。</li><li><strong>论文摘录</strong>：“consistent hashing over table file names”。见 <a href="https://pages.cs.wisc.edu/~remzi/Classes/739/Papers/p215-dageville-snowflake.pdf#page=4" target="_blank" rel="noopener">论文 §3.2.2，PDF 第 4 页／印刷页 218</a>。</li><li><strong>为什么不对</strong>：分配单位是同一张表的不同文件。这样既能复用同一文件的缓存，又能把大表扫描分给多个 worker。若改成按 table id 映射，便会把整张表的初始文件分配和缓存亲和性集中到同一 worker，改变论文所描述的并行扫描与缓存分布机制；后续的 file stealing 是另一项负载调整措施。</li></ul><h3 id="2-向量化执行与延迟物化不是同一个概念【概念混淆】"><a href="#2-向量化执行与延迟物化不是同一个概念【概念混淆】" class="headerlink" title="2. 向量化执行与延迟物化不是同一个概念【概念混淆】"></a>2. 向量化执行与延迟物化不是同一个概念【概念混淆】</h3><ul><li><strong>博客摘录</strong>：“也是 late materialzation”。语境转述：Execution Engine 一节将 vectorized 直接解释为延迟物化。</li><li><strong>论文摘录</strong>：“in batches of a few thousand rows in columnar format”。见 <a href="https://pages.cs.wisc.edu/~remzi/Classes/739/Papers/p215-dageville-snowflake.pdf#page=4" target="_blank" rel="noopener">论文 §3.2.3，PDF 第 4 页</a>。</li><li><strong>为什么不对</strong>：此处说的是按列式批次将中间结果传给下游，避免先生成完整中间结果。延迟物化讨论的是何时把不同列的值组装为元组。两者可以配合，但批处理并不自动等于推迟元组重建；论文此处也没有将二者定义为同义词。</li></ul><h3 id="3-proprietary-engine-被误解成专有硬件【翻译错误】"><a href="#3-proprietary-engine-被误解成专有硬件【翻译错误】" class="headerlink" title="3. proprietary engine 被误解成专有硬件【翻译错误】"></a>3. proprietary engine 被误解成专有硬件【翻译错误】</h3><ul><li><strong>博客摘录</strong>：“专有硬件”。语境转述：Storage Versus Compute 一节据此描述计算层。</li><li><strong>论文摘录</strong>：“(proprietary) shared-nothing engine”。见 <a href="https://pages.cs.wisc.edu/~remzi/Classes/739/Papers/p215-dageville-snowflake.pdf#page=3" target="_blank" rel="noopener">论文 §2，PDF 第 3 页／印刷页 217</a>。</li><li><strong>为什么不对</strong>：proprietary 修饰的是 Snowflake 自有的查询引擎软件，不是硬件。§3.2 随后明确说 VW 由 EC2 实例构成。此处应写成使用 Snowflake 自有的 shared-nothing 引擎。</li></ul><h1 id="Database-paper-part-6"><a href="#Database-paper-part-6" class="headerlink" title="Database paper part 6"></a>Database paper part 6</h1><p>博文：<a href="https://www.calvinneo.com/2024/12/25/database-paper-6/">Database paper part 6</a>。</p><h2 id="PolarDB-Serverless-A-Cloud-Native-Database-for-Disaggregated-Data-Centers"><a href="#PolarDB-Serverless-A-Cloud-Native-Database-for-Disaggregated-Data-Centers" class="headerlink" title="PolarDB Serverless: A Cloud Native Database for Disaggregated Data Centers"></a>PolarDB Serverless: A Cloud Native Database for Disaggregated Data Centers</h2><h3 id="1-双端口网卡被写成了两块网卡【事实错误，影响较小】"><a href="#1-双端口网卡被写成了两块网卡【事实错误，影响较小】" class="headerlink" title="1. 双端口网卡被写成了两块网卡【事实错误，影响较小】"></a>1. 双端口网卡被写成了两块网卡【事实错误，影响较小】</h3><ul><li><strong>博客摘录</strong>：“两个 RDMA NIC”。语境转述：Disaggregated Data Centers 一节用它解释连接两个 ToR 的网络冗余。</li><li><strong>论文摘录</strong>：“a dual-port RDMA NIC”。见 <a href="https://users.cs.utah.edu/~lifeifei/papers/polardbserverless-sigmod21.pdf#page=3" target="_blank" rel="noopener">论文 §2.2，PDF 第 3 页</a>。</li><li><strong>为什么不对</strong>：论文描述的是一块双端口网卡，两个端口分别连接不同 ToR。两块网卡与一块双端口网卡的故障边界不同；原文这里只保证单条网络链路失效时的连续服务，不能把端口冗余改写成网卡冗余。</li></ul><h3 id="2-slab-容量单位应为-GB【单位笔误】"><a href="#2-slab-容量单位应为-GB【单位笔误】" class="headerlink" title="2. slab 容量单位应为 GB【单位笔误】"></a>2. slab 容量单位应为 GB【单位笔误】</h3><ul><li><strong>博客摘录</strong>：“1Gb”。位置：Remote Memory Management。</li><li><strong>论文摘录</strong>：“slab is 1 GB”。见 <a href="https://users.cs.utah.edu/~lifeifei/papers/polardbserverless-sigmod21.pdf#page=4" target="_blank" rel="noopener">论文 §3.1.2，PDF 第 4 页</a>。</li><li><strong>为什么不对</strong>：大写 B 表示字节，小写 b 通常表示比特，二者相差八倍。这里应保留论文的 1 GB，不应按 1 Gb 理解容量。</li></ul><h2 id="Monkey-Optimal-Navigable-Key-Value-Store"><a href="#Monkey-Optimal-Navigable-Key-Value-Store" class="headerlink" title="Monkey: Optimal Navigable Key-Value Store"></a>Monkey: Optimal Navigable Key-Value Store</h2><h3 id="1-单层极限的参数写错，还遗漏了合并策略的区别【明确错误】"><a href="#1-单层极限的参数写错，还遗漏了合并策略的区别【明确错误】" class="headerlink" title="1. 单层极限的参数写错，还遗漏了合并策略的区别【明确错误】"></a>1. 单层极限的参数写错，还遗漏了合并策略的区别【明确错误】</h3><ul><li><strong>博客摘录</strong>：“T 为 1”。语境转述：作者称此时层数 L 为 1，LSM 退化为 log。位置：Tuning the Merge Policy and Size Ratio。</li><li><strong>论文摘录</strong>：“As T approaches Tlim, the number of levels L approaches 1.”。见 <a href="https://nivdayan.github.io/monkeykeyvaluestore.pdf#page=3" target="_blank" rel="noopener">论文 §2，PDF 第 3 页</a>。</li><li><strong>为什么不对</strong>：论文模型中 T 从 2 开始，单层极限是 T 接近 <code>Tlim = N·E/Mbuffer</code>，不是 T=1。并且 §3 区分了两种极限：tiering 退化为 log，leveling 退化为 sorted array。博客前面的 Buffering Updates 已正确说明 T 取上限时 L 为 1，故此处可能是把 T 与 L 混写的笔误；仍需纠正参数，并补全策略条件。</li></ul><h3 id="2-T-2-不能称为读写共同最优点【概括过度】"><a href="#2-T-2-不能称为读写共同最优点【概括过度】" class="headerlink" title="2. T=2 不能称为读写共同最优点【概括过度】"></a>2. T=2 不能称为读写共同最优点【概括过度】</h3><ul><li><strong>博客摘录</strong>：“读写最优”。语境转述：作者据 Figure 4 将 tiering 在 T=2 时的位置如此定性，并说此时才与 leveling 打平。</li><li><strong>论文摘录</strong>：“update cost decreases/increases whereas lookup cost increases/decreases”。见 <a href="https://nivdayan.github.io/monkeykeyvaluestore.pdf#page=4" target="_blank" rel="noopener">论文 §3，PDF 第 4 页</a>。</li><li><strong>为什么欠妥</strong>：在 tiering 模型里，增大 T 仍可降低更新成本，但会增加查询成本；T=2 是两种策略渐近复杂度接合的位置。不能据此推出存在一个读写同时最优的通用点，或 tiering 全面劣于 leveling。选择取决于工作负载和内存配置。</li></ul><h2 id="Are-You-Sure-You-Want-to-Use-MMAP-in-Your-Database-Management-System"><a href="#Are-You-Sure-You-Want-to-Use-MMAP-in-Your-Database-Management-System" class="headerlink" title="Are You Sure You Want to Use MMAP in Your Database Management System?"></a>Are You Sure You Want to Use MMAP in Your Database Management System?</h2><h3 id="1-MMAPv1-与-WiredTiger-的迁移历史属于-MongoDB【明确错误】"><a href="#1-MMAPv1-与-WiredTiger-的迁移历史属于-MongoDB【明确错误】" class="headerlink" title="1. MMAPv1 与 WiredTiger 的迁移历史属于 MongoDB【明确错误】"></a>1. MMAPv1 与 WiredTiger 的迁移历史属于 MongoDB【明确错误】</h3><ul><li><strong>博客摘录</strong>：“MonetDB”。语境转述：在 MMAP Gone Wrong 中，作者将使用 MMAPv1、2015 年改用 WiredTiger 的历史归到这个系统名下。</li><li><strong>论文摘录</strong>：“MongoDB deprecated MMAPv1 and then completely removed it in 2019”。见 <a href="https://db.cs.cmu.edu/papers/2022/cidr2022-p13-crotty.pdf#page=3" target="_blank" rel="noopener">论文 §2.3，PDF 第 3 页</a>。</li><li><strong>为什么不对</strong>：论文明确在讲 MongoDB。MonetDB 是上一段列举的另一个使用 mmap 的系统；把二者混为一谈，会错误归属存储引擎及其更替历史。</li></ul><h2 id="SLM-DB-Single-Level-Key-Value-Store-with-Persistent-Memory"><a href="#SLM-DB-Single-Level-Key-Value-Store-with-Persistent-Memory" class="headerlink" title="SLM-DB: Single-Level Key-Value Store with Persistent Memory"></a>SLM-DB: Single-Level Key-Value Store with Persistent Memory</h2><h3 id="1-leaf-node-scan-的目的不只是合并小文件【解释欠妥】"><a href="#1-leaf-node-scan-的目的不只是合并小文件【解释欠妥】" class="headerlink" title="1. leaf-node-scan 的目的不只是合并小文件【解释欠妥】"></a>1. leaf-node-scan 的目的不只是合并小文件【解释欠妥】</h3><ul><li><strong>博客摘录</strong>：“合并小文件”。位置：Selective Compaction。</li><li><strong>论文摘录</strong>：“improve the sequentiality of KVs stored in L0”。见 <a href="https://www.usenix.org/system/files/fast19-kaiyrakhmet.pdf#page=7" target="_blank" rel="noopener">论文 §3.3，PDF 第 7 页／印刷页 196</a>。</li><li><strong>为什么欠妥</strong>：选择条件关注一个连续键区间分散在多少个不同 SSTable 中，而非各文件是否太小。即使文件都很大，若相邻键分散在太多文件中，范围扫描仍会产生较多随机访问。合并的目标是改善键的存储顺序性，文件数量减少只是可能的结果。</li></ul><h3 id="2-按总重叠率选择、多文件合并，被缩成最大重叠的两文件配对【算法描述错误】"><a href="#2-按总重叠率选择、多文件合并，被缩成最大重叠的两文件配对【算法描述错误】" class="headerlink" title="2. 按总重叠率选择、多文件合并，被缩成最大重叠的两文件配对【算法描述错误】"></a>2. 按总重叠率选择、多文件合并，被缩成最大重叠的两文件配对【算法描述错误】</h3><ul><li><strong>博客摘录</strong>：“最大的 SST”。语境转述：Selective Compaction 一节说数据库把给定 SST s 与和它重叠率最高的那一个 SST 合并。</li><li><strong>论文摘录</strong>：“total sum of overlapping ratios for s”；“maximum overlapping ratio value”。见 <a href="https://www.usenix.org/system/files/fast19-kaiyrakhmet.pdf#page=7" target="_blank" rel="noopener">论文 §3.3，PDF 第 7 页／印刷页 196</a>。</li><li><strong>为什么不对</strong>：论文先为候选表中的每个 s 累加它与其他候选文件的重叠率，选出总分最大的 s′，再和候选表中与 s′ 重叠的文件合并，并限制一次合并的文件数。最大化的是每个候选文件的总分，不是选出与给定 s 重叠最多的单个搭档；后续也不局限于两文件合并。</li></ul><h1 id="Database-paper-part-7"><a href="#Database-paper-part-7" class="headerlink" title="Database paper part 7"></a>Database paper part 7</h1><p>博文：<a href="https://www.calvinneo.com/2025/03/15/database-paper-7/">Database paper part 7</a>。</p><h2 id="We-Ain’t-Afraid-of-No-File-Fragmentation-Causes-and-Prevention-of-Its-Performance-Impact-on-Modern-Flash-SSDs"><a href="#We-Ain’t-Afraid-of-No-File-Fragmentation-Causes-and-Prevention-of-Its-Performance-Impact-on-Modern-Flash-SSDs" class="headerlink" title="We Ain’t Afraid of No File Fragmentation: Causes and Prevention of Its Performance Impact on Modern Flash SSDs"></a>We Ain’t Afraid of No File Fragmentation: Causes and Prevention of Its Performance Impact on Modern Flash SSDs</h2><h3 id="1-文件碎片化与-die-分布不均不是必然关系【表述欠妥；原文引言也有同样简化】"><a href="#1-文件碎片化与-die-分布不均不是必然关系【表述欠妥；原文引言也有同样简化】" class="headerlink" title="1. 文件碎片化与 die 分布不均不是必然关系【表述欠妥；原文引言也有同样简化】"></a>1. 文件碎片化与 die 分布不均不是必然关系【表述欠妥；原文引言也有同样简化】</h3><ul><li><strong>博客摘录</strong>：“不能被放置在 contiguous dies 上”。语境转述：Introduction 一节将这一结果直接归因于文件发生 fragmentation。</li><li><strong>论文摘录</strong>：“presence of file fragmentation does not inevitably result in uneven page distribution over dies”。见 <a href="https://www.usenix.org/system/files/fast24-jun.pdf#page=5" target="_blank" rel="noopener">论文 §2.3，PDF 第 5 页／印刷页 196</a>。</li><li><strong>为什么欠妥</strong>：文件系统块地址是否连续，与 SSD 内部页面在哪些 die 上分布，是不同层次的事情。论文后文给出两类反例：文件有碎片但 die 分布仍均匀；文件没有碎片，却因覆盖写入造成 die 分布失衡。因此更准确的结论是：交错写入等因素可能破坏理想映射，从而增加冲突，不能仅凭文件有碎片就断定内部映射必然失衡。论文引言本身也使用了类似的绝对表述；这里批评的是笔记没有吸收正文限定，而非作者凭空误译。</li></ul><p><strong>数值核验补充</strong>：博客中文将 NVMe 每队列命令数也写成 65,535，并据此平方，和紧随其后的英文摘录不一致。不过，论文 §2.2 与 §3.1 自己也交换了 65,535 和 65,536 对应的队列数、队列深度。本报告不据这篇内部不一致的论文，把它提升为作者独立造成的架构错误。<a href="https://www.usenix.org/system/files/fast24-jun.pdf#page=4" target="_blank" rel="noopener">论文 §2.2</a>、<a href="https://www.usenix.org/system/files/fast24-jun.pdf#page=8" target="_blank" rel="noopener">§3.1</a></p>]]></content>
    
    
    <summary type="html">&lt;p&gt;&lt;strong&gt;Database paper part 1–7：对照论文原文的核查报告&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;核对日期：2026-09-22。按 7 篇博文组织，覆盖其中 23 篇论文／技术报告及 Titan 工程延伸，共保留 &lt;strong&gt;36 处&lt;/strong&gt;值得纠正或澄清的表述。&lt;/p&gt;</summary>
    
    
    
    
    <category term="AIGen" scheme="http://www.calvinneo.com/tags/AIGen/"/>
    
    <category term="数据库" scheme="http://www.calvinneo.com/tags/数据库/"/>
    
    <category term="论文阅读" scheme="http://www.calvinneo.com/tags/论文阅读/"/>
    
  </entry>
  
  <entry>
    <title>既有 Redis 论文修订</title>
    <link href="http://www.calvinneo.com/2026/09/22/redis-blog-source-review/"/>
    <id>http://www.calvinneo.com/2026/09/22/redis-blog-source-review/</id>
    <published>2026-09-22T15:20:33.000Z</published>
    <updated>2026-09-27T03:39:09.075Z</updated>
    
    <content type="html"><![CDATA[<p>核查日期：2026-09-22。使用 chatgpt 6 修订该站 Redis 标签下的六篇文章。</p><p>本地版本依据实际 Git HEAD 确认：</p><table><thead><tr><th>本文简称</th><th>本地源码</th><th>固定提交</th></tr></thead><tbody><tr><td>2018 快照</td><td>redis-unstable-2018-07-23</td><td><a href="https://github.com/redis/redis/commit/b65ddfb16a7060a543b523feadeca1234cffd323" target="_blank" rel="noopener"><code>b65ddfb16a7060a543b523feadeca1234cffd323</code></a></td></tr><tr><td>2020 快照</td><td>redis-c01e94a-2020-08</td><td><a href="https://github.com/redis/redis/commit/c01e94a4319c416c4c231ffbea9e778d52424e30" target="_blank" rel="noopener"><code>c01e94a4319c416c4c231ffbea9e778d52424e30</code></a></td></tr></tbody></table><p>二者均为 unstable 开发快照，不直接等同于 Redis 5.0 / 6.0 正式版。对象篇的 dict 分析使用 2018 快照，其余主要使用作者明确链接的 2020 快照；涉及跨版本结论的地方另行标注。</p><a id="more"></a><p>下文保留 <strong>32 处</strong>值得纠正或补充限定的表述：对象 8 处、Sentinel 6 处、持久化 5 处、事务 4 处、复制 3 处、基础机制 6 处。机制错误、条件遗漏、术语问题与明显笔误分别说明，不把它们视为同等严重。</p><p>每项先以引用块展示关键原话，再以“作者论述（转述）”补足前提、推理与限定，并保留原文位置。引用块中的“……”表示省略；转述不作为作者逐字原话。受同篇逐字引用长度限制，未将所有相关原段落完整转载。源码来自本地对应快照，<code>/* … */</code> 表示中间省略；链接指向可核对的文件和起始行。除对象篇第 1、2 项另做了编译复现，其余结论来自源码和调用路径核查。两个源码目录未作修改。</p><p>当前对象篇已修正缩容扫描可能重复、安全迭代器及 2020 年模块扫描修复背景等旧问题，故未将旧笔记中的相关批评照搬进来。</p><hr><h1 id="Redis底层对象实现原理分析"><a href="#Redis底层对象实现原理分析" class="headerlink" title="Redis底层对象实现原理分析"></a>Redis底层对象实现原理分析</h1><p><a href="https://www.calvinneo.com/2018/07/23/redis_learn_object/">博文原址</a>。dict 以 2018 快照核查，其余以 2020 快照核查。</p><h2 id="1-强制扩容不保证把桶数翻倍"><a href="#1-强制扩容不保证把桶数翻倍" class="headerlink" title="1. 强制扩容不保证把桶数翻倍"></a>1. 强制扩容不保证把桶数翻倍</h2><p><strong>作者原文摘录（节选）：</strong></p><blockquote><p>按照2倍</p></blockquote><p>见<a href="https://www.calvinneo.com/2018/07/23/redis_learn_object/#%E5%93%88%E5%B8%8C%E8%A1%A8%E7%9A%84%E6%89%A9%E5%AE%B9">原文小节</a>。</p><p><strong>作者论述（转述）：</strong>讨论禁止常规扩容后的例外时，作者说负载比例超过默认阈值 5 仍可强制扩容，并把这次容量增长也解释为翻倍。</p><p><strong>源码（2018 快照，<code>b65ddfb</code>）：</strong> <a href="/path/to/redis/redis-unstable-2018-07-23/src/dict.c:933">dict.c:933–954</a> · <a href="https://github.com/redis/redis/blob/b65ddfb16a7060a543b523feadeca1234cffd323/src/dict.c#L933-L954" target="_blank" rel="noopener">固定提交链接</a>。</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br></pre></td><td class="code"><pre><span class="line">     * the number of buckets. */</span><br><span class="line">    <span class="keyword">if</span> (d-&gt;ht[<span class="number">0</span>].used &gt;= d-&gt;ht[<span class="number">0</span>].size &amp;&amp;</span><br><span class="line">        (dict_can_resize ||</span><br><span class="line">         d-&gt;ht[<span class="number">0</span>].used/d-&gt;ht[<span class="number">0</span>].size &gt; dict_force_resize_ratio))</span><br><span class="line">    &#123;</span><br><span class="line">        <span class="keyword">return</span> dictExpand(d, d-&gt;ht[<span class="number">0</span>].used*<span class="number">2</span>);</span><br><span class="line">    &#125;</span><br><span class="line">    <span class="keyword">return</span> DICT_OK;</span><br><span class="line">&#125;</span><br><span class="line"></span><br><span class="line"><span class="comment">/* Our hash table capability is a power of two */</span></span><br><span class="line"><span class="keyword">static</span> <span class="keyword">unsigned</span> <span class="keyword">long</span> _dictNextPower(<span class="keyword">unsigned</span> <span class="keyword">long</span> size)</span><br><span class="line">&#123;</span><br><span class="line">    <span class="keyword">unsigned</span> <span class="keyword">long</span> i = DICT_HT_INITIAL_SIZE;</span><br><span class="line"></span><br><span class="line">    <span class="keyword">if</span> (size &gt;= LONG_MAX) <span class="keyword">return</span> LONG_MAX + <span class="number">1L</span>U;</span><br><span class="line">    <span class="keyword">while</span>(<span class="number">1</span>) &#123;</span><br><span class="line">        <span class="keyword">if</span> (i &gt;= size)</span><br><span class="line">            <span class="keyword">return</span> i;</span><br><span class="line">        i *= <span class="number">2</span>;</span><br><span class="line">    &#125;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure><p><strong>为什么有问题：</strong>传入 <code>dictExpand</code> 的是 <code>used * 2</code>，不是 <code>size * 2</code>；<code>dictExpand</code> 又在第 155 行通过 <code>_dictNextPower</code> 向上取整到 2 的幂。比如旧表有 4 个桶、24 个元素，关闭常规扩容后，<code>24 / 4 &gt; 5</code> 成立，申请容量为 48，最终得到 64 个桶，是原来的 16 倍。只有通常在 <code>used == size</code> 附近触发扩容时，才常见桶数翻倍。这里源码上方的英文注释也不够严谨，应以实际表达式为准。</p><h2 id="2-渐进式-rehash-不是写时复制"><a href="#2-渐进式-rehash-不是写时复制" class="headerlink" title="2. 渐进式 rehash 不是写时复制"></a>2. 渐进式 rehash 不是写时复制</h2><p><strong>作者原文摘录（节选）：</strong></p><blockquote><p>又是COW了</p></blockquote><p>见<a href="https://www.calvinneo.com/2018/07/23/redis_learn_object/#Rehash">原文小节</a>。</p><p><strong>作者论述（转述）：</strong>作者先指出分配新表时尚未迁移旧元素，再追问是否属于写时复制；紧接着给出肯定回答，随后介绍实际迁移函数。</p><p><strong>源码（2018 快照，<code>b65ddfb</code>）：</strong> <a href="/path/to/redis/redis-unstable-2018-07-23/src/dict.c:205">dict.c:205–219</a> · <a href="https://github.com/redis/redis/blob/b65ddfb16a7060a543b523feadeca1234cffd323/src/dict.c#L205-L219" target="_blank" rel="noopener">固定提交链接</a>。</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br></pre></td><td class="code"><pre><span class="line">        <span class="keyword">uint64_t</span> h;</span><br><span class="line"></span><br><span class="line">        nextde = de-&gt;next;</span><br><span class="line">        <span class="comment">/* Get the index in the new hash table */</span></span><br><span class="line">        h = dictHashKey(d, de-&gt;key) &amp; d-&gt;ht[<span class="number">1</span>].sizemask;</span><br><span class="line">        de-&gt;next = d-&gt;ht[<span class="number">1</span>].table[h];</span><br><span class="line">        d-&gt;ht[<span class="number">1</span>].table[h] = de;</span><br><span class="line">        d-&gt;ht[<span class="number">0</span>].used--;</span><br><span class="line">        d-&gt;ht[<span class="number">1</span>].used++;</span><br><span class="line">        de = nextde;</span><br><span class="line">    &#125;</span><br><span class="line">    d-&gt;ht[<span class="number">0</span>].table[d-&gt;rehashidx] = <span class="literal">NULL</span>;</span><br><span class="line">    d-&gt;rehashidx++;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure><p><strong>源码（2018 快照，<code>b65ddfb</code>）：</strong> <a href="/path/to/redis/redis-unstable-2018-07-23/src/dict.c:476">dict.c:476–483</a> · <a href="https://github.com/redis/redis/blob/b65ddfb16a7060a543b523feadeca1234cffd323/src/dict.c#L476-L483" target="_blank" rel="noopener">固定提交链接</a>。</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br></pre></td><td class="code"><pre><span class="line"><span class="function">dictEntry *<span class="title">dictFind</span><span class="params">(dict *d, <span class="keyword">const</span> <span class="keyword">void</span> *key)</span></span></span><br><span class="line"><span class="function"></span>&#123;</span><br><span class="line">    dictEntry *he;</span><br><span class="line">    <span class="keyword">uint64_t</span> h, idx, table;</span><br><span class="line"></span><br><span class="line">    <span class="keyword">if</span> (d-&gt;ht[<span class="number">0</span>].used + d-&gt;ht[<span class="number">1</span>].used == <span class="number">0</span>) <span class="keyword">return</span> <span class="literal">NULL</span>; <span class="comment">/* dict is empty */</span></span><br><span class="line">    <span class="keyword">if</span> (dictIsRehashing(d)) _dictRehashStep(d);</span><br><span class="line">    h = dictHashKey(d, key);</span><br></pre></td></tr></table></figure><p><strong>为什么有问题：</strong>这里重连的是同一批 <code>dictEntry</code> 节点的 <code>next</code> 指针，旧桶随后被清空，并未保留一份可供旧读者使用的副本。甚至 <code>dictFind</code> 这种查找操作也能推进搬迁。它是把迁移成本分摊到多次操作中的<strong>增量迁移</strong>，不是在写入时复制共享数据。Redis 为后台持久化 <code>fork</code> 后使用的操作系统 COW 是另一回事；两者会相互影响内存成本，但不是同一机制。</p><p><strong>第 1、2 项的实际复现：</strong>使用<a href="/path/to/redis/audit/dict-repro.c">独立验证程序</a>，分别链接两个快照中原样的 <code>dict.c</code>、<code>zmalloc.c</code> 和 <code>siphash.c</code>，两次运行均得到：</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">forced expansion: old buckets=4, old entries=24, new buckets=64</span><br><span class="line">dictFind advances rehashidx: 0 -&gt; 1; same dictEntry pointer=yes</span><br></pre></td></tr></table></figure><p>这项实验同时验证了扩容倍率、读操作推进迁移，以及节点本身没有被复制。<a href="/path/to/redis/audit/reproduce.md">编译及运行步骤</a>。</p><h3 id="【Response】"><a href="#【Response】" class="headerlink" title="【Response】"></a>【Response】</h3><p>是的，这里主要还是强调是类似 COW 的方案。</p><h2 id="3-跳表原地更新分数需要同时满足前后边界"><a href="#3-跳表原地更新分数需要同时满足前后边界" class="headerlink" title="3. 跳表原地更新分数需要同时满足前后边界"></a>3. 跳表原地更新分数需要同时满足前后边界</h2><p><strong>作者原文摘录（节选）：</strong></p><blockquote><p>或者是最后一个节点</p></blockquote><p>见<a href="https://www.calvinneo.com/2018/07/23/redis_learn_object/#zslUpdateScore%E7%9A%84%E5%AE%9E%E7%8E%B0">原文小节</a>。</p><p><strong>作者论述（转述）：</strong>作者将可原地改分数的情形列成两项：先判断前驱，再以或关系引出后继；不满足时才删除后重新插入。</p><p><strong>源码（2020 快照，<code>c01e94a</code>）：</strong> <a href="/path/to/redis/redis-c01e94a-2020-08/src/t_zset.c:285">t_zset.c:285–300</a> · <a href="https://github.com/redis/redis/blob/c01e94a4319c416c4c231ffbea9e778d52424e30/src/t_zset.c#L285-L300" target="_blank" rel="noopener">固定提交链接</a>。</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">if</span> ((x-&gt;backward == <span class="literal">NULL</span> || x-&gt;backward-&gt;score &lt; newscore) &amp;&amp;</span><br><span class="line">    (x-&gt;level[<span class="number">0</span>].forward == <span class="literal">NULL</span> || x-&gt;level[<span class="number">0</span>].forward-&gt;score &gt; newscore))</span><br><span class="line">&#123;</span><br><span class="line">    x-&gt;score = newscore;</span><br><span class="line">    <span class="keyword">return</span> x;</span><br><span class="line">&#125;</span><br><span class="line"></span><br><span class="line"><span class="comment">/* No way to reuse the old node: we need to remove and insert a new</span></span><br><span class="line"><span class="comment"> * one at a different place. */</span></span><br><span class="line">zslDeleteNode(zsl, x, update);</span><br><span class="line">zskiplistNode *newnode = zslInsert(zsl,newscore,x-&gt;ele);</span><br><span class="line"><span class="comment">/* We reused the old node x-&gt;ele SDS string, free the node now</span></span><br><span class="line"><span class="comment"> * since zslInsert created a new one. */</span></span><br><span class="line">x-&gt;ele = <span class="literal">NULL</span>;</span><br><span class="line">zslFreeNode(x);</span><br><span class="line"><span class="keyword">return</span> newnode;</span><br></pre></td></tr></table></figure><p><strong>为什么有问题：</strong>源码用 <code>&amp;&amp;</code> 连接两组条件：新分数既不能越过前驱，也不能越过后继。两组内部才各自有 <code>||</code>，分别允许没有前驱或没有后继。该优化使用严格的 <code>&lt;</code> 和 <code>&gt;</code>；与邻居同分也会落入重新插入分支。例：分数 <code>1, 2, 3</code> 的中间节点改成 4，虽然满足前驱小于新分数，但必须移动到末尾，不能原地改。更准确的表述是：前后两侧的条件<strong>同时成立</strong>才原地更新，否则删除旧节点并重新插入。</p><h2 id="4-随机层高是截断的几何分布"><a href="#4-随机层高是截断的几何分布" class="headerlink" title="4. 随机层高是截断的几何分布"></a>4. 随机层高是截断的几何分布</h2><p><strong>作者原文摘录（节选）：</strong></p><blockquote><p>powerlaw</p></blockquote><p>见<a href="https://www.calvinneo.com/2018/07/23/redis_learn_object/#%E8%B7%B3%E8%A1%A8%E9%81%8D%E5%8E%86%E6%8A%BD%E8%B1%A1%E4%B8%BB%E5%B9%B2%E4%BB%A3%E7%A0%81">原文小节</a>。</p><p><strong>作者论述（转述）：</strong>解释随机层高时，作者先说明节点拥有较高层的概率更小，再将这种概率分布归为幂律分布。</p><p><strong>源码（2020 快照，<code>c01e94a</code>）：</strong> <a href="/path/to/redis/redis-c01e94a-2020-08/src/t_zset.c:118">t_zset.c:118–128</a> · <a href="https://github.com/redis/redis/blob/c01e94a4319c416c4c231ffbea9e778d52424e30/src/t_zset.c#L118-L128" target="_blank" rel="noopener">固定提交链接</a>。</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment">/* Returns a random level for the new skiplist node we are going to create.</span></span><br><span class="line"><span class="comment"> * The return value of this function is between 1 and ZSKIPLIST_MAXLEVEL</span></span><br><span class="line"><span class="comment"> * (both inclusive), with a powerlaw-alike distribution where higher</span></span><br><span class="line"><span class="comment"> * levels are less likely to be returned. */</span></span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">zslRandomLevel</span><span class="params">(<span class="keyword">void</span>)</span> </span>&#123;</span><br><span class="line">    <span class="keyword">int</span> level = <span class="number">1</span>;</span><br><span class="line">    <span class="keyword">while</span> ((random()&amp;<span class="number">0xFFFF</span>) &lt; (ZSKIPLIST_P * <span class="number">0xFFFF</span>))</span><br><span class="line">        level += <span class="number">1</span>;</span><br><span class="line">    <span class="keyword">return</span> (level&lt;ZSKIPLIST_MAXLEVEL) ? level : ZSKIPLIST_MAXLEVEL;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure><p><strong>为什么有问题：</strong>每成功通过一次相同概率的随机判断，层高增加 1；失败则停止，最后截断到最大层高。若单次通过概率记为 p，则未到上限时 <code>P(L = k) = (1-p) p^(k-1)</code>，尾概率为 <code>P(L ≥ k) = p^(k-1)</code>，按层高呈指数衰减；这里 p 约为 1/4。它是截断几何分布，而不是按 k 的负幂衰减的幂律分布。源码注释也仅写 <code>powerlaw-alike</code>；把它当作严格的分布名称会误导复杂度分析。</p><h2 id="5-一次罕见哈希结果不能给出集合基数的下界"><a href="#5-一次罕见哈希结果不能给出集合基数的下界" class="headerlink" title="5. 一次罕见哈希结果不能给出集合基数的下界"></a>5. 一次罕见哈希结果不能给出集合基数的下界</h2><p><strong>作者原文摘录（节选）：</strong></p><blockquote><p>至少……8个元素</p></blockquote><p>见<a href="https://www.calvinneo.com/2018/07/23/redis_learn_object/#HLL%E5%8E%9F%E7%90%86">原文小节</a>。</p><p><strong>作者论述（转述）：</strong>作者先以抛掷次数解释前缀出现的概率，再由遇到 001 这一结果，推断当前集合的元素数不小于 8。</p><p><strong>源码（2020 快照，<code>c01e94a</code>）：</strong> <a href="/path/to/redis/redis-c01e94a-2020-08/src/hyperloglog.c:468">hyperloglog.c:468–480</a> · <a href="https://github.com/redis/redis/blob/c01e94a4319c416c4c231ffbea9e778d52424e30/src/hyperloglog.c#L468-L480" target="_blank" rel="noopener">固定提交链接</a>。</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br></pre></td><td class="code"><pre><span class="line">    hash &gt;&gt;= HLL_P; <span class="comment">/* Remove bits used to address the register. */</span></span><br><span class="line">    hash |= ((<span class="keyword">uint64_t</span>)<span class="number">1</span>&lt;&lt;HLL_Q); <span class="comment">/* Make sure the loop terminates</span></span><br><span class="line"><span class="comment">                                     and count will be &lt;= Q+1. */</span></span><br><span class="line">    bit = <span class="number">1</span>;</span><br><span class="line">    count = <span class="number">1</span>; <span class="comment">/* Initialized to 1 since we count the "00000...1" pattern. */</span></span><br><span class="line">    <span class="keyword">while</span>((hash &amp; bit) == <span class="number">0</span>) &#123;</span><br><span class="line">        count++;</span><br><span class="line">        bit &lt;&lt;= <span class="number">1</span>;</span><br><span class="line">    &#125;</span><br><span class="line">    *regp = (<span class="keyword">int</span>) index;</span><br><span class="line">    <span class="keyword">return</span> count;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure><p><strong>为什么有问题：</strong>代码对<strong>单个元素</strong>的哈希就能计算出很大的 count；这不要求先插入相应数量的元素。第一次抽样便出现概率为 1/8 的事件完全可能，集合此时仍可只有 1 个元素。等待该事件出现的期望次数、由最大零串长度得到的统计估计，以及真实基数的确定下界，是三种不同概念。HLL 用许多寄存器和估计器降低误差，并不作这种确定性下界保证。</p><p>集合里只有一个元素 A，假设它的哈希结果恰好是：</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line">集合：&#123;A&#125;</span><br><span class="line">哈希：00110101……</span><br><span class="line">      ↑</span><br><span class="line">      第一个 1 出现在第 3 位</span><br></pre></td></tr></table></figure><p>此时：</p><ul><li>真实元素数量：1。</li><li>按文章的直觉，用 2³ = 8 来推测数量。</li><li>如果进一步说“集合至少有 8 个元素”，就错了——集合明明只有 A。<br>这个结果完全可能发生：均匀随机的哈希以 001 开头，概率就是 1/8，第一次就可能遇到。<br>“平均要尝试 8 次才遇到”不意味着“必须尝试满 8 次才能遇到”。类似中奖概率是 1/8，有人买第一张就中奖了，不能据此断定他至少买过 8 张。<br>实际 Redis HLL 会综合多个桶并进行校正；上面的 8 是文章简化模型的推测，不是说 Redis 对一个元素执行 PFCOUNT 就会返回 8。</li></ul><h2 id="6-寄存器为零与哈希后缀全零不是一回事"><a href="#6-寄存器为零与哈希后缀全零不是一回事" class="headerlink" title="6. 寄存器为零与哈希后缀全零不是一回事"></a>6. 寄存器为零与哈希后缀全零不是一回事</h2><p><strong>作者原文摘录（节选）：</strong></p><blockquote><p>远远大于</p></blockquote><p>见<a href="https://www.calvinneo.com/2018/07/23/redis_learn_object/#HLL%E5%8E%9F%E7%90%86">原文小节</a>。</p><p><strong>作者论述（转述）：</strong>作者猜测零值意味着第一个 1 尚在当前位宽之外，因而代表更大的基数；段末明确询问这一理解是否正确。</p><p><strong>源码（2020 快照，<code>c01e94a</code>）：</strong> <a href="/path/to/redis/redis-c01e94a-2020-08/src/hyperloglog.c:1124">hyperloglog.c:1124–1136</a> · <a href="https://github.com/redis/redis/blob/c01e94a4319c416c4c231ffbea9e778d52424e30/src/hyperloglog.c#L1124-L1136" target="_blank" rel="noopener">固定提交链接</a>。</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment">/* Populate the sparse representation with as many XZERO opcodes as</span></span><br><span class="line"><span class="comment"> * needed to represent all the registers. */</span></span><br><span class="line">aux = HLL_REGISTERS;</span><br><span class="line">s = sdsnewlen(<span class="literal">NULL</span>,sparselen);</span><br><span class="line">p = (<span class="keyword">uint8_t</span>*)s + HLL_HDR_SIZE;</span><br><span class="line"><span class="keyword">while</span>(aux) &#123;</span><br><span class="line">    <span class="keyword">int</span> xzero = HLL_SPARSE_XZERO_MAX_LEN;</span><br><span class="line">    <span class="keyword">if</span> (xzero &gt; aux) xzero = aux;</span><br><span class="line">    HLL_SPARSE_XZERO_SET(p,xzero);</span><br><span class="line">    p += <span class="number">2</span>;</span><br><span class="line">    aux -= xzero;</span><br><span class="line">&#125;</span><br><span class="line">serverAssert((p-(<span class="keyword">uint8_t</span>*)s) == sparselen);</span><br></pre></td></tr></table></figure><p><strong>源码（2020 快照，<code>c01e94a</code>）：</strong> <a href="/path/to/redis/redis-c01e94a-2020-08/src/hyperloglog.c:971">hyperloglog.c:971–973</a> · <a href="https://github.com/redis/redis/blob/c01e94a4319c416c4c231ffbea9e778d52424e30/src/hyperloglog.c#L971-L973" target="_blank" rel="noopener">固定提交链接</a>。</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="keyword">double</span> <span class="title">hllSigma</span><span class="params">(<span class="keyword">double</span> x)</span> </span>&#123;</span><br><span class="line">    <span class="keyword">if</span> (x == <span class="number">1.</span>) <span class="keyword">return</span> INFINITY;</span><br><span class="line">    <span class="keyword">double</span> zPrime;</span><br></pre></td></tr></table></figure><p><strong>源码（2020 快照，<code>c01e94a</code>）：</strong> <a href="/path/to/redis/redis-c01e94a-2020-08/src/hyperloglog.c:1039">hyperloglog.c:1039–1047</a> · <a href="https://github.com/redis/redis/blob/c01e94a4319c416c4c231ffbea9e778d52424e30/src/hyperloglog.c#L1039-L1047" target="_blank" rel="noopener">固定提交链接</a>。</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">double</span> z = m * hllTau((m-reghisto[HLL_Q+<span class="number">1</span>])/(<span class="keyword">double</span>)m);</span><br><span class="line"><span class="keyword">for</span> (j = HLL_Q; j &gt;= <span class="number">1</span>; --j) &#123;</span><br><span class="line">    z += reghisto[j];</span><br><span class="line">    z *= <span class="number">0.5</span>;</span><br><span class="line">&#125;</span><br><span class="line">z += m * hllSigma(reghisto[<span class="number">0</span>]/(<span class="keyword">double</span>)m);</span><br><span class="line">E = llroundl(HLL_ALPHA_INF*m*m/z);</span><br><span class="line"></span><br><span class="line"><span class="keyword">return</span> (<span class="keyword">uint64_t</span>) E;</span><br></pre></td></tr></table></figure><p><strong>为什么有问题：</strong>刚创建的 HLL 把全部寄存器初始化为 0，表示尚无元素映射到这些桶。全零寄存器直方图使 <code>hllSigma(1)</code> 返回无穷大，最终估计基数为 0。相反，如果<strong>某个元素</strong>去掉桶下标后的哈希位恰好全零，<code>hllPatLen</code> 会添加哨兵位并得到 <code>HLL_Q + 1</code>，即 51，而不是 0。这两种“零”的含义相反。作者后面正确说明了新对象用 XZERO 初始化，所以这里也构成文章内部的概念冲突。</p><h2 id="7-连续相同值超过四个桶，不会因此转换成-dense"><a href="#7-连续相同值超过四个桶，不会因此转换成-dense" class="headerlink" title="7. 连续相同值超过四个桶，不会因此转换成 dense"></a>7. 连续相同值超过四个桶，不会因此转换成 dense</h2><p><strong>作者原文摘录（节选）：</strong></p><blockquote><p>超过4</p></blockquote><p>见<a href="https://www.calvinneo.com/2018/07/23/redis_learn_object/#Dense%E5%92%8CSparse%E7%BB%93%E6%9E%84">原文小节</a>。</p><p><strong>作者论述（转述）：</strong>作者分别讨论寄存器的取值和重复数量，认为同值连续桶数超出单条 VAL 的容量也会触发 dense 转换。</p><p><strong>源码（2020 快照，<code>c01e94a</code>）：</strong> <a href="/path/to/redis/redis-c01e94a-2020-08/src/hyperloglog.c:660">hyperloglog.c:660–662</a> · <a href="https://github.com/redis/redis/blob/c01e94a4319c416c4c231ffbea9e778d52424e30/src/hyperloglog.c#L660-L662" target="_blank" rel="noopener">固定提交链接</a>。</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment">/* If the count is too big to be representable by the sparse representation</span></span><br><span class="line"><span class="comment"> * switch to dense representation. */</span></span><br><span class="line"><span class="keyword">if</span> (count &gt; HLL_SPARSE_VAL_MAX_VALUE) <span class="keyword">goto</span> promote;</span><br></pre></td></tr></table></figure><p><strong>源码（2020 快照，<code>c01e94a</code>）：</strong> <a href="/path/to/redis/redis-c01e94a-2020-08/src/hyperloglog.c:831">hyperloglog.c:831–832</a> · <a href="https://github.com/redis/redis/blob/c01e94a4319c416c4c231ffbea9e778d52424e30/src/hyperloglog.c#L831-L832" target="_blank" rel="noopener">固定提交链接</a>。</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">if</span> (deltalen &gt; <span class="number">0</span> &amp;&amp;</span><br><span class="line">    sdslen(o-&gt;ptr)+deltalen &gt; server.hll_sparse_max_bytes) <span class="keyword">goto</span> promote;</span><br></pre></td></tr></table></figure><p><strong>源码（2020 快照，<code>c01e94a</code>）：</strong> <a href="/path/to/redis/redis-c01e94a-2020-08/src/hyperloglog.c:854">hyperloglog.c:854–874</a> · <a href="https://github.com/redis/redis/blob/c01e94a4319c416c4c231ffbea9e778d52424e30/src/hyperloglog.c#L854-L874" target="_blank" rel="noopener">固定提交链接</a>。</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br></pre></td><td class="code"><pre><span class="line">    <span class="comment">/* We need two adjacent VAL opcodes to try a merge, having</span></span><br><span class="line"><span class="comment">     * the same value, and a len that fits the VAL opcode max len. */</span></span><br><span class="line">    <span class="keyword">if</span> (p+<span class="number">1</span> &lt; end &amp;&amp; HLL_SPARSE_IS_VAL(p+<span class="number">1</span>)) &#123;</span><br><span class="line">        <span class="keyword">int</span> v1 = HLL_SPARSE_VAL_VALUE(p);</span><br><span class="line">        <span class="keyword">int</span> v2 = HLL_SPARSE_VAL_VALUE(p+<span class="number">1</span>);</span><br><span class="line">        <span class="keyword">if</span> (v1 == v2) &#123;</span><br><span class="line">            <span class="keyword">int</span> len = HLL_SPARSE_VAL_LEN(p)+HLL_SPARSE_VAL_LEN(p+<span class="number">1</span>);</span><br><span class="line">            <span class="keyword">if</span> (len &lt;= HLL_SPARSE_VAL_MAX_LEN) &#123;</span><br><span class="line">                HLL_SPARSE_VAL_SET(p+<span class="number">1</span>,v1,len);</span><br><span class="line">                memmove(p,p+<span class="number">1</span>,end-p);</span><br><span class="line">                sdsIncrLen(o-&gt;ptr,<span class="number">-1</span>);</span><br><span class="line">                end--;</span><br><span class="line">                <span class="comment">/* After a merge we reiterate without incrementing 'p'</span></span><br><span class="line"><span class="comment">                 * in order to try to merge the just merged value with</span></span><br><span class="line"><span class="comment">                 * a value on its right. */</span></span><br><span class="line">                <span class="keyword">continue</span>;</span><br><span class="line">            &#125;</span><br><span class="line">        &#125;</span><br><span class="line">    &#125;</span><br><span class="line">    p++;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure><p><strong>为什么有问题：</strong>4 是<strong>单个 VAL opcode</strong>能表示的连续桶数上限，不是整个 sparse 表示的上限。连续 5 个相同非零寄存器可以用长度为 4 和 1 的两个 VAL 表示；不能合并时只需保留相邻 opcode。<code>hllSparseSet</code> 在更新寄存器时触发自动转换的条件是 count 大于可编码上限 32，或本次扩展后的编码字节数超过配置阈值。其他操作如 PFMERGE 还存在额外转换路径，这里只讨论该更新函数。文章后文也描述了转换条件，但前面的这一条仍会让人误解 sparse 的能力。</p><h2 id="8-HLL-非法标记的赋值方向写反了"><a href="#8-HLL-非法标记的赋值方向写反了" class="headerlink" title="8. HLL 非法标记的赋值方向写反了"></a>8. HLL 非法标记的赋值方向写反了</h2><p><strong>作者原文摘录（节选）：</strong></p><blockquote><p>设置invalid为0</p></blockquote><p>见<a href="https://www.calvinneo.com/2018/07/23/redis_learn_object/#hllCount%E5%87%BD%E6%95%B0">原文小节</a>。</p><p><strong>作者论述（转述）：</strong>介绍估算函数的错误参数时，作者把非法编码对应的标志写成 0，并表示合法时不改写这个参数。</p><p><strong>源码（2020 快照，<code>c01e94a</code>）：</strong> <a href="/path/to/redis/redis-c01e94a-2020-08/src/hyperloglog.c:932">hyperloglog.c:932–935</a> · <a href="https://github.com/redis/redis/blob/c01e94a4319c416c4c231ffbea9e778d52424e30/src/hyperloglog.c#L932-L935" target="_blank" rel="noopener">固定提交链接</a>。</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line">        &#125;</span><br><span class="line">    &#125;</span><br><span class="line">    <span class="keyword">if</span> (idx != HLL_REGISTERS &amp;&amp; invalid) *invalid = <span class="number">1</span>;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure><p><strong>源码（2020 快照，<code>c01e94a</code>）：</strong> <a href="/path/to/redis/redis-c01e94a-2020-08/src/hyperloglog.c:1284">hyperloglog.c:1284–1291</a> · <a href="https://github.com/redis/redis/blob/c01e94a4319c416c4c231ffbea9e778d52424e30/src/hyperloglog.c#L1284-L1291" target="_blank" rel="noopener">固定提交链接</a>。</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">int</span> invalid = <span class="number">0</span>;</span><br><span class="line"><span class="comment">/* Recompute it and update the cached value. */</span></span><br><span class="line">card = hllCount(hdr,&amp;invalid);</span><br><span class="line"><span class="keyword">if</span> (invalid) &#123;</span><br><span class="line">    addReplySds(c,sdsnew(invalid_hll_err));</span><br><span class="line">    <span class="keyword">return</span>;</span><br><span class="line">&#125;</span><br><span class="line">hdr-&gt;card[<span class="number">0</span>] = card &amp; <span class="number">0xff</span>;</span><br></pre></td></tr></table></figure><p><strong>为什么有问题：</strong>出错时设置的是 <code>*invalid = 1</code>；合法时不改写。调用者先把 invalid 初始化为 0，之后检查非零值决定是否向客户端返回错误。如果照文章描述实现调用逻辑，就会把损坏的 HLL 当成有效数据。这是明确的标志极性错误，很可能是文字笔误，但会影响对错误处理路径的理解。</p><hr><h1 id="Redis-Sentinel实现原理分析"><a href="#Redis-Sentinel实现原理分析" class="headerlink" title="Redis Sentinel实现原理分析"></a>Redis Sentinel实现原理分析</h1><p>原文：<a href="https://www.calvinneo.com/2020/10/18/redis-sentinel/">Redis Sentinel实现原理分析</a>。以下以本地 <strong>2020 年源码快照 <code>c01e94a4319c416c4c231ffbea9e778d52424e30</code></strong> 为准；目录为 <code>redis-c01e94a-2020-08</code>。这是开发快照，<code>src/version.h</code> 为 <code>999.999.999</code>，不能称为某个正式 Redis 发行版。源码均为节选。</p><h2 id="1-其他-Sentinel-的下线判断不会直接使本机把-Master-标为-SDOWN"><a href="#1-其他-Sentinel-的下线判断不会直接使本机把-Master-标为-SDOWN" class="headerlink" title="1. 其他 Sentinel 的下线判断不会直接使本机把 Master 标为 SDOWN"></a>1. 其他 Sentinel 的下线判断不会直接使本机把 Master 标为 SDOWN</h2><p><strong>作者原文摘录（节选）：</strong></p><blockquote><p>也设置为 SDOWN 么？是的</p></blockquote><p><a href="https://www.calvinneo.com/2020/10/18/redis-sentinel/#sentinelRedisInstance">原文位置：sentinelRedisInstance</a>。</p><p><strong>作者论述（转述）：</strong>作者询问其他哨兵的下线意见是否会让本机也将主库判为 SDOWN，并肯定回答；随后又区分了本机与对端的判断标志。</p><p><strong>对应源码，2020 快照：</strong><a href="/path/to/redis/redis-c01e94a-2020-08/src/sentinel.c:3788">sentinel.c:3788</a>，<code>sentinelReceiveIsMasterDownReply()</code>：</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line">ri-&gt;last_master_down_reply_time = mstime();</span><br><span class="line"><span class="keyword">if</span> (r-&gt;element[<span class="number">0</span>]-&gt;integer == <span class="number">1</span>) &#123;</span><br><span class="line">    ri-&gt;flags |= SRI_MASTER_DOWN;</span><br><span class="line">&#125; <span class="keyword">else</span> &#123;</span><br><span class="line">    ri-&gt;flags &amp;= ~SRI_MASTER_DOWN;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure><p>这里的 <code>ri</code> 是回复消息的<strong>另一 Sentinel</strong> 的本地描述对象。统计客观下线时，<a href="/path/to/redis/redis-c01e94a-2020-08/src/sentinel.c:3739">sentinel.c:3739</a>：</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">if</span> (master-&gt;flags &amp; SRI_S_DOWN) &#123;</span><br><span class="line">    <span class="comment">/* Is down for enough sentinels? */</span></span><br><span class="line">    quorum = <span class="number">1</span>; <span class="comment">/* the current sentinel. */</span></span><br><span class="line">    <span class="comment">/* Count all the other sentinels. */</span></span><br><span class="line">    di = dictGetIterator(master-&gt;sentinels);</span><br><span class="line">    <span class="keyword">while</span>((de = dictNext(di)) != <span class="literal">NULL</span>) &#123;</span><br><span class="line">        sentinelRedisInstance *ri = dictGetVal(de);</span><br><span class="line"></span><br><span class="line">        <span class="keyword">if</span> (ri-&gt;flags &amp; SRI_MASTER_DOWN) quorum++;</span><br><span class="line">    &#125;</span><br><span class="line">    dictReleaseIterator(di);</span><br><span class="line">    <span class="keyword">if</span> (quorum &gt;= master-&gt;quorum) odown = <span class="number">1</span>;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure><p><strong>为何不对：</strong>接收回复只更新对端 Sentinel 对 Master 的判断 <code>SRI_MASTER_DOWN</code>，不会设置 <code>master-&gt;flags</code> 的 <code>SRI_S_DOWN</code>。本机必须先通过自己的超时/角色检查作出 SDOWN 判断，才会汇总其他 Sentinel 的意见判断 ODOWN。因此，即使其他 Sentinel 都报告下线，本机仍可能认为 Master 正常。原文随后区分两个 flag 的说明基本正确，所以这里应定性为<strong>前后矛盾的错误回答</strong>，而非作者全文都混淆两者。</p><h2 id="2-Sentinel-的-Leader-选票不以其报告-Master-下线为生效条件"><a href="#2-Sentinel-的-Leader-选票不以其报告-Master-下线为生效条件" class="headerlink" title="2. Sentinel 的 Leader 选票不以其报告 Master 下线为生效条件"></a>2. Sentinel 的 Leader 选票不以其报告 Master 下线为生效条件</h2><p><strong>作者原文摘录（节选）：</strong></p><blockquote><p>有SRI_MASTER_DOWN标记时有效力</p></blockquote><p><a href="https://www.calvinneo.com/2020/10/18/redis-sentinel/#sentinelAskMasterStateToOtherSentinels">原文位置：sentinelAskMasterStateToOtherSentinels</a>。</p><p><strong>作者论述（转述）：</strong>作者解释清理过期选票时，断言只有带 <code>SRI_MASTER_DOWN</code> 标志，<code>ri-&gt;leader</code> 才生效；并提醒该字段不始终代表当前 Leader。</p><p><strong>对应源码，2020 快照：</strong><a href="/path/to/redis/redis-c01e94a-2020-08/src/sentinel.c:3135">sentinel.c:3135</a>，处理 <code>is-master-down-by-addr</code> 请求：</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">if</span> (!sentinel.tilt &amp;&amp; ri &amp;&amp; (ri-&gt;flags &amp; SRI_S_DOWN) &amp;&amp;</span><br><span class="line">                            (ri-&gt;flags &amp; SRI_MASTER))</span><br><span class="line">    isdown = <span class="number">1</span>;</span><br><span class="line"></span><br><span class="line"><span class="comment">/* Vote for the master (or fetch the previous vote) if the request</span></span><br><span class="line"><span class="comment"> * includes a runid, otherwise the sender is not seeking for a vote. */</span></span><br><span class="line"><span class="keyword">if</span> (ri &amp;&amp; ri-&gt;flags &amp; SRI_MASTER &amp;&amp; strcasecmp(c-&gt;argv[<span class="number">5</span>]-&gt;ptr,<span class="string">"*"</span>)) &#123;</span><br><span class="line">    leader = sentinelVoteLeader(ri,(<span class="keyword">uint64_t</span>)req_epoch,</span><br><span class="line">                                    c-&gt;argv[<span class="number">5</span>]-&gt;ptr,</span><br><span class="line">                                    &amp;leader_epoch);</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure><p>真正统计 Leader 选票时，<a href="/path/to/redis/redis-c01e94a-2020-08/src/sentinel.c:3943">sentinel.c:3943</a>：</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment">/* Count other sentinels votes */</span></span><br><span class="line">di = dictGetIterator(master-&gt;sentinels);</span><br><span class="line"><span class="keyword">while</span>((de = dictNext(di)) != <span class="literal">NULL</span>) &#123;</span><br><span class="line">    sentinelRedisInstance *ri = dictGetVal(de);</span><br><span class="line">    <span class="keyword">if</span> (ri-&gt;leader != <span class="literal">NULL</span> &amp;&amp; ri-&gt;leader_epoch == sentinel.current_epoch)</span><br><span class="line">        sentinelLeaderIncr(counters,ri-&gt;leader);</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure><p><strong>为何不对：</strong>下线意见和选举授权是两个独立结果。一个 Sentinel 可以回复 <code>isdown=0</code>，同时依据 epoch 规则授予 Leader 选票；接收端也会独立保存该选票。统计时检查的是 <code>leader</code> 和 <code>leader_epoch</code>，没有检查 <code>SRI_MASTER_DOWN</code>。把两种投票混在一起，会错误地认为所有参与 Leader 授权的 Sentinel 都必须先判定 Master 下线。</p><h2 id="3-连接共享复用的是同一个远端-Sentinel-的连接"><a href="#3-连接共享复用的是同一个远端-Sentinel-的连接" class="headerlink" title="3. 连接共享复用的是同一个远端 Sentinel 的连接"></a>3. 连接共享复用的是同一个远端 Sentinel 的连接</h2><p><strong>作者原文摘录（节选）：</strong></p><blockquote><p>复用这个实例</p></blockquote><p><a href="https://www.calvinneo.com/2020/10/18/redis-sentinel/#sentinelTryConnectionSharing">原文位置：sentinelTryConnectionSharing</a>。</p><p><strong>作者论述（转述）：</strong>作者先称共享的是本机已有的主库连接，再称遍历找到 <code>ri-&gt;master</code> 就复用它；虽表示代码难懂，结论使用肯定语气。</p><p><strong>对应源码，2020 快照：</strong><a href="/path/to/redis/redis-c01e94a-2020-08/src/sentinel.c:1064">sentinel.c:1064</a>：</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">while</span>((de = dictNext(di)) != <span class="literal">NULL</span>) &#123;</span><br><span class="line">    sentinelRedisInstance *master = dictGetVal(de), *match;</span><br><span class="line">    <span class="comment">/* We want to share with the same physical Sentinel referenced</span></span><br><span class="line"><span class="comment">     * in other masters, so skip our master. */</span></span><br><span class="line">    <span class="keyword">if</span> (master == ri-&gt;master) <span class="keyword">continue</span>;</span><br><span class="line">    match = getSentinelRedisInstanceByAddrAndRunID(master-&gt;sentinels,</span><br><span class="line">                                                   <span class="literal">NULL</span>,<span class="number">0</span>,ri-&gt;runid);</span><br><span class="line">    <span class="keyword">if</span> (match == <span class="literal">NULL</span>) <span class="keyword">continue</span>; <span class="comment">/* No match. */</span></span><br><span class="line">    <span class="keyword">if</span> (match == ri) <span class="keyword">continue</span>; <span class="comment">/* Should never happen but... safer. */</span></span><br><span class="line"></span><br><span class="line">    <span class="comment">/* We identified a matching Sentinel, great! Let's free our link</span></span><br><span class="line"><span class="comment">     * and use the one of the matching Sentinel. */</span></span><br><span class="line">    releaseInstanceLink(ri-&gt;link,<span class="literal">NULL</span>);</span><br><span class="line">    ri-&gt;link = match-&gt;link;</span><br><span class="line">    match-&gt;link-&gt;refcount++;</span><br></pre></td></tr></table></figure><p><strong>为何不对：</strong>条件恰好相反：遇到 <code>ri-&gt;master</code> 会跳过。它在<strong>其他 Master 的 <code>sentinels</code> 字典</strong>中，寻找 <code>runid</code> 相同的远端 Sentinel，然后共享 <code>match-&gt;link</code>。例如本机同时监控 M1、M2，而远端 S2 也监控两者，本机会有两个描述 S2 的对象，但这两个对象可以共用本机到 S2 的连接；它们不会借用本机到 M1/M2 的连接，也不是多个 Sentinel 进程共用一个 TCP 连接。</p><h2 id="4-act-ping-time-不是最近一次发送-PING-的时间"><a href="#4-act-ping-time-不是最近一次发送-PING-的时间" class="headerlink" title="4. act_ping_time 不是最近一次发送 PING 的时间"></a>4. <code>act_ping_time</code> 不是最近一次发送 PING 的时间</h2><p><strong>作者原文摘录（节选）：</strong></p><blockquote><p>最后一个PING发出的时间</p></blockquote><p><a href="https://www.calvinneo.com/2020/10/18/redis-sentinel/#sentinelCheckSubjectivelyDown">原文位置：sentinelCheckSubjectivelyDown</a>。</p><p><strong>作者论述（转述）：</strong>作者将 <code>act_ping_time</code> 解释成最近发送 PING 的时刻，认为零值表示已收 PONG、尚未再发；另称 <code>last_ping_time</code> 不随 PONG 清零。</p><p><strong>对应源码，2020 快照：</strong><a href="/path/to/redis/redis-c01e94a-2020-08/src/sentinel.c:2704">sentinel.c:2704</a>：</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">if</span> (retval == C_OK) &#123;</span><br><span class="line">    ri-&gt;link-&gt;pending_commands++;</span><br><span class="line">    ri-&gt;link-&gt;last_ping_time = mstime();</span><br><span class="line">    <span class="comment">/* We update the active ping time only if we received the pong for</span></span><br><span class="line"><span class="comment">     * the previous ping, otherwise we are technically waiting since the</span></span><br><span class="line"><span class="comment">     * first ping that did not receive a reply. */</span></span><br><span class="line">    <span class="keyword">if</span> (ri-&gt;link-&gt;act_ping_time == <span class="number">0</span>)</span><br><span class="line">        ri-&gt;link-&gt;act_ping_time = ri-&gt;link-&gt;last_ping_time;</span><br></pre></td></tr></table></figure><p>下线检测使用它累计等待时间，<a href="/path/to/redis/redis-c01e94a-2020-08/src/sentinel.c:3665">sentinel.c:3665</a>：</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">if</span> (ri-&gt;link-&gt;act_ping_time)</span><br><span class="line">    elapsed = mstime() - ri-&gt;link-&gt;act_ping_time;</span><br><span class="line"><span class="keyword">else</span> <span class="keyword">if</span> (ri-&gt;link-&gt;disconnected)</span><br><span class="line">    elapsed = mstime() - ri-&gt;link-&gt;last_avail_time;</span><br></pre></td></tr></table></figure><p><strong>为何不对：</strong>每次发送成功都会更新 <code>last_ping_time</code>；只有 <code>act_ping_time</code> 已清零，才会将它更新。因此在连续未获得可接受回复时，<code>act_ping_time</code> 保留的是这段等待的起点，不是最近一个 PING。比如第 0、1、2 秒均发送 PING 而始终无有效回复，第 2 秒的等待时间仍从第 0 秒计算，否则持续发送心跳就可能不断推迟故障超时。新建 link 时也会预设这个起点，以检测尚未成功建立连接的超时。</p><h2 id="5-PUBLISH、订阅模式和-Hiredis-是否阻塞是三个不同问题"><a href="#5-PUBLISH、订阅模式和-Hiredis-是否阻塞是三个不同问题" class="headerlink" title="5. PUBLISH、订阅模式和 Hiredis 是否阻塞是三个不同问题"></a>5. <code>PUBLISH</code>、订阅模式和 Hiredis 是否阻塞是三个不同问题</h2><p><strong>作者原文摘录（节选）：</strong></p><blockquote><p>PUBLISH</p></blockquote><p><a href="https://www.calvinneo.com/2020/10/18/redis-sentinel/#%E8%BF%9E%E6%8E%A5">原文位置：连接</a>。</p><p><strong>作者论述（转述）：</strong>作者借 redis-cli 执行 PUBLISH 后无法继续发命令，对比 Hiredis 不阻塞；前文仅把防止广播丢失列为双连接的一种解释。</p><p><strong>对应源码，2020 快照：</strong><a href="/path/to/redis/redis-c01e94a-2020-08/src/pubsub.c:400">pubsub.c:400</a>：</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">publishCommand</span><span class="params">(client *c)</span> </span>&#123;</span><br><span class="line">    <span class="keyword">int</span> receivers = pubsubPublishMessage(c-&gt;argv[<span class="number">1</span>],c-&gt;argv[<span class="number">2</span>]);</span><br><span class="line">    <span class="keyword">if</span> (server.cluster_enabled)</span><br><span class="line">        clusterPropagatePublish(c-&gt;argv[<span class="number">1</span>],c-&gt;argv[<span class="number">2</span>]);</span><br><span class="line">    <span class="keyword">else</span></span><br><span class="line">        forceCommandPropagation(c,PROPAGATE_REPL);</span><br><span class="line">    addReplyLongLong(c,receivers);</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure><p>订阅模式下的服务端约束，<a href="/path/to/redis/redis-c01e94a-2020-08/src/server.c:3725">server.c:3725</a>：</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment">/* Only allow a subset of commands in the context of Pub/Sub if the</span></span><br><span class="line"><span class="comment"> * connection is in RESP2 mode. With RESP3 there are no limits. */</span></span><br><span class="line"><span class="keyword">if</span> ((c-&gt;flags &amp; CLIENT_PUBSUB &amp;&amp; c-&gt;resp == <span class="number">2</span>) &amp;&amp;</span><br><span class="line">    c-&gt;cmd-&gt;proc != pingCommand &amp;&amp;</span><br><span class="line">    c-&gt;cmd-&gt;proc != subscribeCommand &amp;&amp;</span><br><span class="line">    c-&gt;cmd-&gt;proc != unsubscribeCommand &amp;&amp;</span><br><span class="line">    c-&gt;cmd-&gt;proc != psubscribeCommand &amp;&amp;</span><br><span class="line">    c-&gt;cmd-&gt;proc != punsubscribeCommand) &#123;</span><br><span class="line">    rejectCommandFormat(c,</span><br><span class="line">        <span class="string">"Can't execute '%s': only (P)SUBSCRIBE / "</span></span><br><span class="line">        <span class="string">"(P)UNSUBSCRIBE / PING / QUIT are allowed in this context"</span>,</span><br><span class="line">        c-&gt;cmd-&gt;name);</span><br><span class="line">    <span class="keyword">return</span> C_OK;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure><p><strong>为何不对：</strong>普通连接执行 <code>PUBLISH</code> 会收到订阅接收者数量的整数回复，不会因此进入订阅模式。原文示例实际发送的是 <code>SUBSCRIBE</code>。在这里使用的 RESP2 模式下，即便 Hiredis 函数返回了、或者异步调用成功入队，也不代表订阅连接能成功执行 <code>SET</code>；服务端仍会拒绝。因此分开 <code>cc</code> 和 <code>pc</code> 的关键理由包括订阅连接的协议限制及持续接收推送的需要，不能用客户端调用是否返回来判断是否可以复用。上述结论限定于 RESP2，源码已经明确 RESP3 没有同样的命令限制。</p><h2 id="6-当选要求达到-quorum，不是严格超过-quorum"><a href="#6-当选要求达到-quorum，不是严格超过-quorum" class="headerlink" title="6. 当选要求达到 quorum，不是严格超过 quorum"></a>6. 当选要求达到 <code>quorum</code>，不是严格超过 <code>quorum</code></h2><p><strong>作者原文摘录（节选）：</strong></p><blockquote><p>必须大于master-&gt;quorum</p></blockquote><p><a href="https://www.calvinneo.com/2020/10/18/redis-sentinel/#%E3%80%90%E6%8E%A5%E4%B8%8A%E3%80%91sentinelGetLeader">原文位置：sentinelGetLeader</a>。</p><p><strong>作者论述（转述）：</strong>作者列出当选者须获得绝对多数、严格超过配置 quorum；随后贴出实际只排除票数小于门槛的判断。</p><p><strong>对应源码，2020 快照：</strong><a href="/path/to/redis/redis-c01e94a-2020-08/src/sentinel.c:3983">sentinel.c:3983</a>：</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line">voters_quorum = voters/<span class="number">2</span>+<span class="number">1</span>;</span><br><span class="line"><span class="keyword">if</span> (winner &amp;&amp; (max_votes &lt; voters_quorum || max_votes &lt; master-&gt;quorum))</span><br><span class="line">    winner = <span class="literal">NULL</span>;</span><br></pre></td></tr></table></figure><p><strong>为何不对：</strong>两个条件是票数 <code>&gt;= floor(voters/2)+1</code>，并且 <code>&gt;= master-&gt;quorum</code>。例如已知 3 个 Sentinel、配置 quorum 为 2，获得 2 票即可；按原文的严格大于理解则错误地要求 3 票。这是影响故障转移可用性判断的边界错误，不能把对投票总人数的“超过半数”套到配置 quorum 上。</p><hr><h1 id="Redis持久化机制实现"><a href="#Redis持久化机制实现" class="headerlink" title="Redis持久化机制实现"></a>Redis持久化机制实现</h1><p>原文：<a href="https://www.calvinneo.com/2021/03/13/redis-persist/">Redis持久化机制实现</a>。以下主要核对 **2020-08 源码快照 <code>c01e94a4319c416c4c231ffbea9e778d52424e30</code>**（目录 <code>redis-c01e94a-2020-08</code>）。这是仓库提交标识，不把它误称为某个正式发布版；下列代码块中的 <code>/* … */</code> 表示省略无关代码。</p><h2 id="1-32-MB-的增量-fsync-阈值，不是已成功保存的-RDB-的持久性边界"><a href="#1-32-MB-的增量-fsync-阈值，不是已成功保存的-RDB-的持久性边界" class="headerlink" title="1. 32 MB 的增量 fsync 阈值，不是已成功保存的 RDB 的持久性边界"></a>1. 32 MB 的增量 fsync 阈值，不是已成功保存的 RDB 的持久性边界</h2><p><strong>作者原文摘录（节选）：</strong></p><blockquote><p>写32MB才刷盘</p></blockquote><p><a href="https://www.calvinneo.com/2021/03/13/redis-persist/#rdbSave">原文位置：rdbSave</a>。</p><p><strong>作者论述（转述）：</strong>作者从增量同步的 32 MB 阈值推断宕机会破坏持久性；往下分析保存流程时，又说明写完须先强制同步，再改名替换文件。</p><p><strong>对应源码（2020-08）：</strong><a href="/path/to/redis/redis-c01e94a-2020-08/src/rdb.c:1315">src/rdb.c:1315</a>、<a href="/path/to/redis/redis-c01e94a-2020-08/src/rdb.c:1331">src/rdb.c:1331</a>，函数 <code>rdbSave</code>：</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br></pre></td><td class="code"><pre><span class="line"><span class="built_in">snprintf</span>(tmpfile,<span class="number">256</span>,<span class="string">"temp-%d.rdb"</span>, (<span class="keyword">int</span>) getpid());</span><br><span class="line">fp = fopen(tmpfile,<span class="string">"w"</span>);</span><br><span class="line"><span class="comment">/* … */</span></span><br><span class="line"><span class="keyword">if</span> (server.rdb_save_incremental_fsync)</span><br><span class="line">    rioSetAutoSync(&amp;rdb,REDIS_AUTOSYNC_BYTES);</span><br><span class="line"></span><br><span class="line"><span class="keyword">if</span> (rdbSaveRio(&amp;rdb,&amp;error,RDBFLAGS_NONE,rsi) == C_ERR) &#123;</span><br><span class="line">    errno = error;</span><br><span class="line">    <span class="keyword">goto</span> werr;</span><br><span class="line">&#125;</span><br><span class="line"></span><br><span class="line"><span class="comment">/* Make sure data will not remain on the OS's output buffers */</span></span><br><span class="line"><span class="keyword">if</span> (fflush(fp) == EOF) <span class="keyword">goto</span> werr;</span><br><span class="line"><span class="keyword">if</span> (fsync(fileno(fp)) == <span class="number">-1</span>) <span class="keyword">goto</span> werr;</span><br><span class="line"><span class="keyword">if</span> (fclose(fp) == EOF) <span class="keyword">goto</span> werr;</span><br><span class="line"></span><br><span class="line"><span class="comment">/* Use RENAME to make sure the DB file is changed atomically only</span></span><br><span class="line"><span class="comment"> * if the generate DB file is ok. */</span></span><br><span class="line"><span class="keyword">if</span> (rename(tmpfile,filename) == <span class="number">-1</span>) &#123;</span><br></pre></td></tr></table></figure><p><strong>为什么欠妥：</strong>32 MB 控制的是生成临时快照过程中的分段同步。即使最后一段不足 32 MB，甚至整个 RDB 都不到 32 MB，成功路径也必须执行末尾的 <code>fflush</code> 和 <code>fsync</code>，然后才替换目标文件。不能由这个阈值推出成功的 RDB 留有最后 32 MB 未同步。作者紧接着其实也解释了最终的 <code>fsync</code>；这里的问题是前面以 32 MB 阈值解释持久性风险的因果关系欠妥，并非文章遗漏了最终同步步骤。</p><p>生成新快照途中崩溃，新快照可能失败，但代码此时尚未用它替换旧快照。RDB 不能逐笔保障最近写入，主要是因为它保存离散时刻的快照；这一点与是否启用增量 fsync 应分开。更准确的说法是：<strong>增量 fsync 用来分摊快照写盘压力，最终保存仍执行完整同步；快照之间的更新则不由 RDB 实时保存。</strong> 配置文件也把该选项的目的写为减少延迟尖峰，见 <a href="/path/to/redis/redis-c01e94a-2020-08/redis.conf:1723">redis.conf:1723</a>。这里不额外推导操作系统、文件系统和硬件在一切断电情形下的保证。</p><h2 id="2-BGREWRITEAOF-期间，旧-AOF-仍然追加新写入"><a href="#2-BGREWRITEAOF-期间，旧-AOF-仍然追加新写入" class="headerlink" title="2. BGREWRITEAOF 期间，旧 AOF 仍然追加新写入"></a>2. BGREWRITEAOF 期间，旧 AOF 仍然追加新写入</h2><p><strong>作者原文摘录（节选）：</strong></p><blockquote><p>旧的AOF在BGREWRITEAOF成功之前不会被修改</p></blockquote><p><a href="https://www.calvinneo.com/2021/03/13/redis-persist/#feedAppendOnlyFile">原文位置：feedAppendOnlyFile</a>。</p><p><strong>作者论述（转述）：</strong>作者先说明重写时需要另存新增命令，随后认为旧文件在重写完成前保持不变，并以此解释为何重写失败也不会丢数据。</p><p><strong>对应源码（2020-08）：</strong><a href="/path/to/redis/redis-c01e94a-2020-08/src/aof.c:642">src/aof.c:642</a>，<code>feedAppendOnlyFile</code>：</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">if</span> (server.aof_state == AOF_ON)</span><br><span class="line">    server.aof_buf = sdscatlen(server.aof_buf,buf,sdslen(buf));</span><br><span class="line"><span class="comment">/* … */</span></span><br><span class="line"><span class="keyword">if</span> (server.aof_child_pid != <span class="number">-1</span>)</span><br><span class="line">    aofRewriteBufferAppend((<span class="keyword">unsigned</span> <span class="keyword">char</span>*)buf,sdslen(buf));</span><br></pre></td></tr></table></figure><p><a href="/path/to/redis/redis-c01e94a-2020-08/src/aof.c:394">src/aof.c:394</a>，正常 AOF 刷写：</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">nwritten = aofWrite(server.aof_fd,server.aof_buf,sdslen(server.aof_buf));</span><br></pre></td></tr></table></figure><p><a href="/path/to/redis/redis-c01e94a-2020-08/src/aof.c:1784">src/aof.c:1784</a>，重写成功、完成文件替换后才切换描述符：</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line">&#125; <span class="keyword">else</span> &#123;</span><br><span class="line">    <span class="comment">/* AOF enabled, replace the old fd with the new one. */</span></span><br><span class="line">    oldfd = server.aof_fd;</span><br><span class="line">    server.aof_fd = newfd;</span><br></pre></td></tr></table></figure><p><strong>为什么不对：</strong>开启 AOF 的正常运行期间，新增修改会同时进入普通 AOF 缓冲区与重写差异缓冲区。普通缓冲区继续写入旧的 <code>server.aof_fd</code>；旧文件因此持续增长，并非冻结不变。重写不成功时还能继续使用旧文件，恰恰依赖这条正常追加路径。</p><p>更准确的说法是：<strong>旧 AOF 在重写成功前不会被重写结果替换或截断，但仍接收正常追加。</strong> 重写失败本身不要求丢弃旧 AOF；是否可能因另一次故障损失最近写入，还取决于原有同步策略，不能把重写机制解释成无条件的数据零丢失保证。</p><h2 id="3-everysec-的这段分支推迟的是-write，而且可能先回复客户端"><a href="#3-everysec-的这段分支推迟的是-write，而且可能先回复客户端" class="headerlink" title="3. everysec 的这段分支推迟的是 write，而且可能先回复客户端"></a>3. everysec 的这段分支推迟的是 write，而且可能先回复客户端</h2><p><strong>作者原文摘录（节选）：</strong></p><blockquote><p>延迟这次fsync</p></blockquote><p><a href="https://www.calvinneo.com/2021/03/13/redis-persist/#flushAppendOnlyFile">原文位置：flushAppendOnlyFile</a>。</p><p><strong>作者论述（转述）：</strong>作者认为后台同步会阻塞写入，因而需要延后此次同步并由定时任务补做；但 force 为 1 时仍强制写入。他还将回复安排在写 AOF 之后。</p><p><strong>对应源码（2020-08）：</strong><a href="/path/to/redis/redis-c01e94a-2020-08/src/aof.c:362">src/aof.c:362</a>：</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">if</span> (server.aof_fsync == AOF_FSYNC_EVERYSEC &amp;&amp; !force) &#123;</span><br><span class="line">    <span class="comment">/* With this append fsync policy we do background fsyncing.</span></span><br><span class="line"><span class="comment">     * If the fsync is still in progress we can try to delay</span></span><br><span class="line"><span class="comment">     * the write for a couple of seconds. */</span></span><br><span class="line">    <span class="keyword">if</span> (sync_in_progress) &#123;</span><br><span class="line">        <span class="keyword">if</span> (server.aof_flush_postponed_start == <span class="number">0</span>) &#123;</span><br><span class="line">            <span class="comment">/* No previous write postponing, remember that we are</span></span><br><span class="line"><span class="comment">             * postponing the flush and return. */</span></span><br><span class="line">            server.aof_flush_postponed_start = server.unixtime;</span><br><span class="line">            <span class="keyword">return</span>;</span><br><span class="line">        &#125; <span class="keyword">else</span> <span class="keyword">if</span> (server.unixtime - server.aof_flush_postponed_start &lt; <span class="number">2</span>) &#123;</span><br><span class="line">            <span class="comment">/* We were already waiting for fsync to finish, but for less</span></span><br><span class="line"><span class="comment">             * than two seconds this is still ok. Postpone again. */</span></span><br><span class="line">            <span class="keyword">return</span>;</span><br><span class="line">        &#125;</span><br></pre></td></tr></table></figure><p>真正的 <code>aofWrite</code> 在该提前返回分支之后，见 <a href="/path/to/redis/redis-c01e94a-2020-08/src/aof.c:394">src/aof.c:394</a>。而 <a href="/path/to/redis/redis-c01e94a-2020-08/src/server.c:2222">src/server.c:2222</a> 的 <code>beforeSleep</code> 是：</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment">/* Write the AOF buffer on disk */</span></span><br><span class="line">flushAppendOnlyFile(<span class="number">0</span>);</span><br><span class="line"></span><br><span class="line"><span class="comment">/* Handle writes with pending output buffers. */</span></span><br><span class="line">handleClientsWithPendingWritesUsingThreads();</span><br></pre></td></tr></table></figure><p><strong>为什么不对：</strong>此时后台的 fsync 已经在运行，代码没有把这个正在运行的调用推迟；它在新一轮 <code>aofWrite</code> 之前返回，把新数据暂留在 Redis 的 AOF 缓冲区。等待达到阈值后才继续尝试 write，即使前一次 fsync 还没有结束。</p><p><code>beforeSleep</code> 会在 <code>flushAppendOnlyFile</code> 返回后继续处理客户端输出，所以这里连“每次回复前均已完成 AOF 的 write”都不是无条件保证，更不能把 write 等同于 fsync 已完成。更准确的说法是：<strong>everysec 用后台 fsync；后台同步繁忙时可推迟下一次 write，期间客户端仍可能收到成功回复。</strong> <code>force=1</code> 跳过的是这段推迟 write 的逻辑。</p><h2 id="4-always-并非逐条命令独立-fsync，no-也并非数据永远不落盘"><a href="#4-always-并非逐条命令独立-fsync，no-也并非数据永远不落盘" class="headerlink" title="4. always 并非逐条命令独立 fsync，no 也并非数据永远不落盘"></a>4. always 并非逐条命令独立 fsync，no 也并非数据永远不落盘</h2><p><strong>作者原文摘录（节选）：</strong></p><blockquote><p>每个命令刷盘一次</p><p>从不刷盘</p></blockquote><p><a href="https://www.calvinneo.com/2021/03/13/redis-persist/#flushAppendOnlyFile">原文位置：flushAppendOnlyFile</a>。</p><p><strong>作者论述（转述）：</strong>作者在解释客户端回复之前的 AOF 刷写时，列出逐命令、按秒和不刷三种策略，并将第一种评价为安全性最高、速度最低。</p><p><strong>对应源码（2020-08）：</strong>普通命令先把序列化结果追加到同一个 <code>server.aof_buf</code>，见前文的 <a href="/path/to/redis/redis-c01e94a-2020-08/src/aof.c:642">src/aof.c:642</a>。随后 <code>flushAppendOnlyFile</code> 刷写整段缓冲区，并按策略同步，见 <a href="/path/to/redis/redis-c01e94a-2020-08/src/aof.c:394">src/aof.c:394</a>、<a href="/path/to/redis/redis-c01e94a-2020-08/src/aof.c:503">src/aof.c:503</a>：</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br></pre></td><td class="code"><pre><span class="line">nwritten = aofWrite(server.aof_fd,server.aof_buf,sdslen(server.aof_buf));</span><br><span class="line"><span class="comment">/* … */</span></span><br><span class="line"><span class="keyword">if</span> (server.aof_fsync == AOF_FSYNC_ALWAYS) &#123;</span><br><span class="line">    <span class="comment">/* redis_fsync is defined as fdatasync() for Linux in order to avoid</span></span><br><span class="line"><span class="comment">     * flushing metadata. */</span></span><br><span class="line">    latencyStartMonitor(latency);</span><br><span class="line">    redis_fsync(server.aof_fd); <span class="comment">/* Let's try to get this data on the disk */</span></span><br></pre></td></tr></table></figure><p>配置文件 <a href="/path/to/redis/redis-c01e94a-2020-08/redis.conf:1108">redis.conf:1108</a> 的定义尤其明确：</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line"># Redis supports three different modes:</span><br><span class="line">#</span><br><span class="line"># no: don&apos;t fsync, just let the OS flush the data when it wants. Faster.</span><br><span class="line"># always: fsync after every write to the append only log. Slow, Safest.</span><br><span class="line"># everysec: fsync only one time every second. Compromise.</span><br></pre></td></tr></table></figure><p><strong>为什么欠妥：</strong>若一次读入多个完整的 pipeline 命令，输入处理循环可以先执行它们，再到事件循环边界刷出累积的 AOF，因此多个命令可以共享一次 fsync；事务中的多条写命令也会累积到该缓冲区。相应循环见 <a href="/path/to/redis/redis-c01e94a-2020-08/src/networking.c:1843">src/networking.c:1843</a>。always 的核心是每批 AOF 写出后的同步，而不是命令数量与 fsync 次数一一对应。</p><p>no 则表示常规追加路径不由 Redis 主动请求 fsync，仍会执行 write，由操作系统安排写回。重写、关闭等其他路径中的同步也不能由该选项概括为永远不发生。更准确的说法是：<strong>always 每次 AOF 刷写后同步；everysec 按秒调度后台同步；no 将常规写回时机交给操作系统。</strong></p><h2 id="5-AOF-格式的说明范围不完整：这两个快照都支持默认开启的-RDB-前缀"><a href="#5-AOF-格式的说明范围不完整：这两个快照都支持默认开启的-RDB-前缀" class="headerlink" title="5. AOF 格式的说明范围不完整：这两个快照都支持默认开启的 RDB 前缀"></a>5. AOF 格式的说明范围不完整：这两个快照都支持默认开启的 RDB 前缀</h2><p><strong>作者原文摘录（节选）：</strong></p><blockquote><p>协议文本</p></blockquote><p><a href="https://www.calvinneo.com/2021/03/13/redis-persist/">原文位置：开头对 AOF 的定义</a>。</p><p><strong>作者论述（转述）：</strong>作者开篇以二进制快照和命令文本对比 RDB、AOF；介绍重写时又用多次递增合并为一次赋值，说明如何减少保存当前数据所需的命令。</p><p><strong>对应源码（2020-08）：</strong><a href="/path/to/redis/redis-c01e94a-2020-08/src/aof.c:1431">src/aof.c:1431</a>，<code>rewriteAppendOnlyFile</code>：</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">if</span> (server.aof_use_rdb_preamble) &#123;</span><br><span class="line">    <span class="keyword">int</span> error;</span><br><span class="line">    <span class="keyword">if</span> (rdbSaveRio(&amp;aof,&amp;error,RDBFLAGS_AOF_PREAMBLE,<span class="literal">NULL</span>) == C_ERR) &#123;</span><br><span class="line">        errno = error;</span><br><span class="line">        <span class="keyword">goto</span> werr;</span><br><span class="line">    &#125;</span><br><span class="line">&#125; <span class="keyword">else</span> &#123;</span><br><span class="line">    <span class="keyword">if</span> (rewriteAppendOnlyFileRio(&amp;aof) == C_ERR) <span class="keyword">goto</span> werr;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure><p><a href="/path/to/redis/redis-c01e94a-2020-08/redis.conf:1196">redis.conf:1196</a>：</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line"># When rewriting the AOF file, Redis is able to use an RDB preamble in the</span><br><span class="line"># AOF file for faster rewrites and recoveries. When this option is turned</span><br><span class="line"># on the rewritten AOF file is composed of two different stanzas:</span><br><span class="line">#</span><br><span class="line">#   [RDB file][AOF tail]</span><br></pre></td></tr></table></figure><p>该配置在 <a href="/path/to/redis/redis-c01e94a-2020-08/redis.conf:1205">redis.conf:1205</a> 为 <code>aof-use-rdb-preamble yes</code>，程序默认值也为真，见 <a href="/path/to/redis/redis-c01e94a-2020-08/src/config.c:2255">src/config.c:2255</a>。<strong>2018-07-23 快照 <code>b65ddfb16a7060a543b523feadeca1234cffd323</code></strong> 也已有相同分支及默认配置，见 <a href="/path/to/redis/redis-unstable-2018-07-23/src/aof.c:1323">src/aof.c:1323</a>、<a href="/path/to/redis/redis-unstable-2018-07-23/redis.conf:781">redis.conf:781</a>。</p><p><strong>为什么欠妥：</strong>普通追加部分确实用命令协议表示，但启用该选项后，重写时的存量数据用二进制 RDB 写在 AOF 开头，后面才接命令增量。读取 AOF 也先识别并加载 RDB 前缀，再解析命令尾部，见 <a href="/path/to/redis/redis-c01e94a-2020-08/src/aof.c:755">src/aof.c:755</a>。因此应区分传统命令式 AOF 与混合格式；这并不是拿较新的 Redis 特性反驳旧版本。</p><hr><h1 id="Redis事务的实现"><a href="#Redis事务的实现" class="headerlink" title="Redis事务的实现"></a>Redis事务的实现</h1><p>原文：<a href="https://www.calvinneo.com/2021/03/23/redis-transaction/">Redis事务的实现</a>。以下代码对应 **2020-08 源码快照 <code>c01e94a4319c416c4c231ffbea9e778d52424e30</code>**，与文章展示的 ACL 检查、RESP3 回复等代码一致。</p><h2 id="1-缺少失败回滚，不宜直接概括为-Redis-事务完全没有原子性"><a href="#1-缺少失败回滚，不宜直接概括为-Redis-事务完全没有原子性" class="headerlink" title="1. 缺少失败回滚，不宜直接概括为 Redis 事务完全没有原子性"></a>1. 缺少失败回滚，不宜直接概括为 Redis 事务完全没有原子性</h2><p><strong>作者原文摘录（节选）：</strong></p><blockquote><p>Redis并没有原子性</p></blockquote><p><a href="https://www.calvinneo.com/2021/03/23/redis-transaction/#%E7%AE%80%E4%BB%8B">原文位置：简介</a>。</p><p><strong>作者论述（转述）：</strong>作者先说明事务命令执行完才处理其他客户端，随后以不支持回滚为理由否定原子性，并强调 DISCARD 只用于命令排队阶段。</p><p><strong>对应源码（2020-08）：</strong><a href="/path/to/redis/redis-c01e94a-2020-08/src/multi.c:176">src/multi.c:176</a>、<a href="/path/to/redis/redis-c01e94a-2020-08/src/multi.c:195">src/multi.c:195</a>：</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br></pre></td><td class="code"><pre><span class="line">addReplyArrayLen(c,c-&gt;mstate.count);</span><br><span class="line"><span class="keyword">for</span> (j = <span class="number">0</span>; j &lt; c-&gt;mstate.count; j++) &#123;</span><br><span class="line">    c-&gt;argc = c-&gt;mstate.commands[j].argc;</span><br><span class="line">    c-&gt;argv = c-&gt;mstate.commands[j].argv;</span><br><span class="line">    c-&gt;cmd = c-&gt;mstate.commands[j].cmd;</span><br><span class="line">    <span class="comment">/* … */</span></span><br><span class="line">    <span class="keyword">int</span> acl_keypos;</span><br><span class="line">    <span class="keyword">int</span> acl_retval = ACLCheckCommandPerm(c,&amp;acl_keypos);</span><br><span class="line">    <span class="keyword">if</span> (acl_retval != ACL_OK) &#123;</span><br><span class="line">        <span class="comment">/* … */</span></span><br><span class="line">    &#125; <span class="keyword">else</span> &#123;</span><br><span class="line">        call(c,server.loading ? CMD_CALL_NONE : CMD_CALL_FULL);</span><br><span class="line">    &#125;</span><br><span class="line">    <span class="comment">/* … */</span></span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure><p><strong>为什么欠妥：</strong>这里需要区分两种含义。作者关于“执行时出错没有回滚”的判断是对的：某个命令出错不意味着此前的成功修改被撤销，也不必然停止后续命令。例如 <code>MULTI → SET k text → INCR k → SET done 1 → EXEC</code>，<code>INCR</code> 失败，但两个 <code>SET</code> 的效果仍然保留；<code>INCR</code> 的解析失败会直接返回，见 <a href="/path/to/redis/redis-c01e94a-2020-08/src/t_string.c:345">src/t_string.c:345</a>，外围事务循环继续运行。</p><p>但同一个执行循环也表明，正常命令执行期间，其他客户端的命令不能插入这个事务的命令序列。Redis 在这种“不可穿插执行”的意义上提供事务原子执行。<strong>更准确的结论是：Redis 事务可以作为不可穿插的命令序列执行，但不提供关系数据库式的执行失败后全部回滚语义。</strong> 如果特指 ACID 中的全有或全无，就应明确这个限定，而不是笼统否定所有原子性含义。</p><h2 id="2-WATCH-冲突是在执行前放弃队列，不是撤销已执行操作"><a href="#2-WATCH-冲突是在执行前放弃队列，不是撤销已执行操作" class="headerlink" title="2. WATCH 冲突是在执行前放弃队列，不是撤销已执行操作"></a>2. WATCH 冲突是在执行前放弃队列，不是撤销已执行操作</h2><p><strong>作者原文摘录（节选）：</strong></p><blockquote><p>如果这些key被修改，则事务回滚</p></blockquote><p><a href="https://www.calvinneo.com/2021/03/23/redis-transaction/#watch">原文位置：watch</a>。</p><p><strong>作者论述（转述）：</strong>作者将 WATCH 描述为 MULTI 前对若干键建立监控；当这些键后来被修改，就把相应事务的结果称作回滚。</p><p><strong>对应源码（2020-08）：</strong><a href="/path/to/redis/redis-c01e94a-2020-08/src/multi.c:164">src/multi.c:164</a>，冲突分支位于执行循环之前：</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">if</span> (c-&gt;flags &amp; (CLIENT_DIRTY_CAS|CLIENT_DIRTY_EXEC)) &#123;</span><br><span class="line">    addReply(c, c-&gt;flags &amp; CLIENT_DIRTY_EXEC ? shared.execaborterr :</span><br><span class="line">                                               shared.nullarray[c-&gt;resp]);</span><br><span class="line">    discardTransaction(c);</span><br><span class="line">    <span class="keyword">goto</span> handle_monitor;</span><br><span class="line">&#125;</span><br><span class="line"></span><br><span class="line"><span class="comment">/* Exec all the queued commands */</span></span><br><span class="line">unwatchAllKeys(c); <span class="comment">/* Unwatch ASAP otherwise we'll waste CPU cycles */</span></span><br></pre></td></tr></table></figure><p><a href="/path/to/redis/redis-c01e94a-2020-08/src/multi.c:83">src/multi.c:83</a>：</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">discardTransaction</span><span class="params">(client *c)</span> </span>&#123;</span><br><span class="line">    freeClientMultiState(c);</span><br><span class="line">    initClientMultiState(c);</span><br><span class="line">    c-&gt;flags &amp;= ~(CLIENT_MULTI|CLIENT_DIRTY_CAS|CLIENT_DIRTY_EXEC);</span><br><span class="line">    unwatchAllKeys(c);</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure><p><strong>为什么不对：</strong>发生 WATCH 冲突时，排队的事务命令还没有执行。这里清理的是队列、事务标志与监视关系，没有恢复旧值的操作。其他客户端对被监视键作出的修改也不会被撤销。</p><p>例如客户端 A <code>WATCH k</code> 后，客户端 B 把 <code>k</code> 改成 <code>2</code>；A 随后的事务因冲突未执行，<code>k</code> 仍然是 B 写入的 <code>2</code>。准确表述应为：<strong>WATCH 冲突使 EXEC 放弃尚未执行的事务，客户端可重新读取并重试。</strong></p><h2 id="3-WATCH-冲突返回-null，与成功执行空事务的空数组不同"><a href="#3-WATCH-冲突返回-null，与成功执行空事务的空数组不同" class="headerlink" title="3. WATCH 冲突返回 null，与成功执行空事务的空数组不同"></a>3. WATCH 冲突返回 null，与成功执行空事务的空数组不同</h2><p><strong>作者原文摘录（节选）：</strong></p><blockquote><p>对于CLIENT_DIRTY_CAS返回空数组</p></blockquote><p><a href="https://www.calvinneo.com/2021/03/23/redis-transaction/#exec">原文位置：exec</a>。</p><p><strong>作者论述（转述）：</strong>作者区分执行前的两类标志：监视键变化时给出特殊结果而非错误，入队阶段出错则返回 EXECABORT；前者被称为空数组。</p><p><strong>对应源码（2020-08）：</strong><a href="/path/to/redis/redis-c01e94a-2020-08/src/multi.c:164">src/multi.c:164</a> 在 <code>CLIENT_DIRTY_CAS</code> 分支返回 <code>shared.nullarray[c-&gt;resp]</code>。这些对象在 <a href="/path/to/redis/redis-c01e94a-2020-08/src/server.c:2259">src/server.c:2259</a>、<a href="/path/to/redis/redis-c01e94a-2020-08/src/server.c:2305">src/server.c:2305</a> 中有明确区分：</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line">shared.emptyarray = createObject(OBJ_STRING,sdsnew(<span class="string">"*0\r\n"</span>));</span><br><span class="line"><span class="comment">/* … */</span></span><br><span class="line">shared.nullarray[<span class="number">0</span>] = <span class="literal">NULL</span>;</span><br><span class="line">shared.nullarray[<span class="number">1</span>] = <span class="literal">NULL</span>;</span><br><span class="line">shared.nullarray[<span class="number">2</span>] = createObject(OBJ_STRING,sdsnew(<span class="string">"*-1\r\n"</span>));</span><br><span class="line">shared.nullarray[<span class="number">3</span>] = createObject(OBJ_STRING,sdsnew(<span class="string">"_\r\n"</span>));</span><br></pre></td></tr></table></figure><p>而成功执行的事务使用 <a href="/path/to/redis/redis-c01e94a-2020-08/src/multi.c:176">src/multi.c:176</a>：</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">addReplyArrayLen(c,c-&gt;mstate.count);</span><br></pre></td></tr></table></figure><p><strong>为什么不对：</strong>RESP2 下 WATCH 冲突得到 null array（<code>*-1\r\n</code>），RESP3 下得到 null（<code>_\r\n</code>）；真正的零元素数组是 <code>*0\r\n</code>。<code>MULTI</code> 后直接 <code>EXEC</code> 可成功返回空数组，与因冲突没有执行事务不是同一结果。这一区别会直接影响客户端判断是否需要重试，不能用同一个“空数组”概括。</p><p>2018-07-23 快照同样使用 <code>shared.nullmultibulk</code> 表示冲突，见 <a href="/path/to/redis/redis-unstable-2018-07-23/src/multi.c:133">src/multi.c:133</a>，不是 2020 年才出现的语义。</p><h2 id="4-执行后更新-mstate，主要是维护被改写参数的所有权与清理，不是此时才保障传播内容"><a href="#4-执行后更新-mstate，主要是维护被改写参数的所有权与清理，不是此时才保障传播内容" class="headerlink" title="4. 执行后更新 mstate，主要是维护被改写参数的所有权与清理，不是此时才保障传播内容"></a>4. 执行后更新 mstate，主要是维护被改写参数的所有权与清理，不是此时才保障传播内容</h2><p><strong>作者原文摘录（节选）：</strong></p><blockquote><p>确保Slave和AOF的数据一致性</p></blockquote><p><a href="https://www.calvinneo.com/2021/03/23/redis-transaction/#exec">原文位置：exec</a>。</p><p><strong>作者论述（转述）：</strong>作者以 SPOP 改写成 SREM 为例，说明执行会改变命令及参数，因此需要写回事务队列；他将此操作解释为保证副本与 AOF 一致。</p><p><strong>对应源码（2020-08）：</strong><a href="/path/to/redis/redis-c01e94a-2020-08/src/multi.c:208">src/multi.c:208</a>：</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br></pre></td><td class="code"><pre><span class="line">    call(c,server.loading ? CMD_CALL_NONE : CMD_CALL_FULL);</span><br><span class="line">&#125;</span><br><span class="line"></span><br><span class="line"><span class="comment">/* Commands may alter argc/argv, restore mstate. */</span></span><br><span class="line">c-&gt;mstate.commands[j].argc = c-&gt;argc;</span><br><span class="line">c-&gt;mstate.commands[j].argv = c-&gt;argv;</span><br><span class="line">c-&gt;mstate.commands[j].cmd = c-&gt;cmd;</span><br></pre></td></tr></table></figure><p>但 <code>call</code> 内部已经使用当前改写后的参数传播，见 <a href="/path/to/redis/redis-c01e94a-2020-08/src/server.c:3433">src/server.c:3433</a>：</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">if</span> (propagate_flags != PROPAGATE_NONE &amp;&amp; !(c-&gt;cmd-&gt;flags &amp; CMD_MODULE))</span><br><span class="line">    propagate(c-&gt;cmd,c-&gt;db-&gt;id,c-&gt;argv,c-&gt;argc,propagate_flags);</span><br></pre></td></tr></table></figure><p>改写可以释放旧参数数组，见 <a href="/path/to/redis/redis-c01e94a-2020-08/src/networking.c:2636">src/networking.c:2636</a>：</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">for</span> (j = <span class="number">0</span>; j &lt; c-&gt;argc; j++) decrRefCount(c-&gt;argv[j]);</span><br><span class="line">zfree(c-&gt;argv);</span><br><span class="line"><span class="comment">/* Replace argv and argc with our new versions. */</span></span><br><span class="line">c-&gt;argv = argv;</span><br><span class="line">c-&gt;argc = argc;</span><br></pre></td></tr></table></figure><p>事务结束后，<code>discardTransaction</code> 则会调用 <a href="/path/to/redis/redis-c01e94a-2020-08/src/multi.c:43">src/multi.c:43</a> 清理队列：</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">for</span> (j = <span class="number">0</span>; j &lt; c-&gt;mstate.count; j++) &#123;</span><br><span class="line">    <span class="keyword">int</span> i;</span><br><span class="line">    multiCmd *mc = c-&gt;mstate.commands+j;</span><br><span class="line"></span><br><span class="line">    <span class="keyword">for</span> (i = <span class="number">0</span>; i &lt; mc-&gt;argc; i++)</span><br><span class="line">        decrRefCount(mc-&gt;argv[i]);</span><br><span class="line">    zfree(mc-&gt;argv);</span><br><span class="line">&#125;</span><br><span class="line">zfree(c-&gt;mstate.commands);</span><br></pre></td></tr></table></figure><p><strong>为什么欠妥：</strong>把 <code>SPOP</code> 等命令改写为确定性操作，确实与复制、AOF 重放的一致性有关；但文章把这个作用归给了之后更新 <code>mstate</code> 的动作，混淆了两个步骤。传播发生在 <code>call</code> 内，早于写回队列。队列必须跟上新 <code>argv/argc</code>，否则稍后的释放会访问已释放的旧数组，还可能遗漏新数组。</p><p>更准确的解释是：<strong>命令改写使传播具有确定性；把结果写回事务状态，使队列继续拥有正确的命令参数，并能在事务结束时正确释放。</strong></p><hr><h1 id="Redis主从复制"><a href="#Redis主从复制" class="headerlink" title="Redis主从复制"></a>Redis主从复制</h1><p>原文：<a href="https://www.calvinneo.com/2021/05/15/redis-replication/">Redis主从复制</a>。以下仍以 <strong>2020 年源码快照 <code>c01e94a4319c416c4c231ffbea9e778d52424e30</code></strong> 为主。三个问题均另核对了本地 **2018 年快照 <code>b65ddfb16a7060a543b523feadeca1234cffd323</code>**，不存在把两个版本混用导致的误判。</p><h2 id="1-PSYNC-请求的-offset-是下一待接收字节的位置"><a href="#1-PSYNC-请求的-offset-是下一待接收字节的位置" class="headerlink" title="1. PSYNC 请求的 offset 是下一待接收字节的位置"></a>1. PSYNC 请求的 offset 是下一待接收字节的位置</h2><p><strong>作者原文摘录（节选）：</strong></p><blockquote><p>offset 表示 Slave 接受到最后命令的偏移量，以字节计算</p></blockquote><p><a href="https://www.calvinneo.com/2021/05/15/redis-replication/#PSYNC%E5%91%BD%E4%BB%A4%E7%94%A8%E6%B3%95">原文位置：PSYNC命令用法</a>。</p><p><strong>作者论述（转述）：</strong>作者把 PSYNC 的 offset 定义为从库最后收到命令的字节偏移；后文所贴发送代码却在缓存偏移上加一。</p><p><strong>对应源码，2020 快照：</strong><a href="/path/to/redis/redis-c01e94a-2020-08/src/replication.c:1969">replication.c:1969</a>：</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">if</span> (server.cached_master) &#123;</span><br><span class="line">    psync_replid = server.cached_master-&gt;replid;</span><br><span class="line">    <span class="built_in">snprintf</span>(psync_offset,<span class="keyword">sizeof</span>(psync_offset),<span class="string">"%lld"</span>, server.cached_master-&gt;reploff+<span class="number">1</span>);</span><br></pre></td></tr></table></figure><p>真正发送请求，<a href="/path/to/redis/redis-c01e94a-2020-08/src/replication.c:1980">replication.c:1980</a>：</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">reply = sendSynchronousCommand(SYNC_CMD_WRITE,conn,<span class="string">"PSYNC"</span>,psync_replid,psync_offset,<span class="literal">NULL</span>);</span><br></pre></td></tr></table></figure><p>2018 快照也有同样的 <code>reploff+1</code>，见 <a href="/path/to/redis/redis-unstable-2018-07-23/src/replication.c:1441">replication.c:1441</a>。</p><p><strong>为何不对：</strong>文章混淆了从库已经处理到的复制偏移量和 PSYNC 请求的起点。常规部分同步请求传的是 <code>cached_master-&gt;reploff + 1</code>：若已经处理到字节 N，就请求从 N+1 开始。主库按该起点截取 backlog，而不会自动替请求参数再加一。<code>PSYNC ? -1</code> 是另一个表示无法提供有效复制历史的特殊请求。原文后面虽然贴出了正确的 <code>+1</code> 源码，开头的参数定义没有把这一区别讲清楚。</p><h2 id="2-repl-transfer-size-初始化为-1，表示尚未读取传输头"><a href="#2-repl-transfer-size-初始化为-1，表示尚未读取传输头" class="headerlink" title="2. repl_transfer_size 初始化为 -1，表示尚未读取传输头"></a>2. <code>repl_transfer_size</code> 初始化为 -1，表示尚未读取传输头</h2><p><strong>作者原文摘录（节选）：</strong></p><blockquote><p>repl_transfer_size为1</p></blockquote><p><a href="https://www.calvinneo.com/2021/05/15/redis-replication/#syncWithMaster-%E6%8F%A1%E6%89%8B%E4%BB%A5%E5%8F%8A%E5%87%86%E5%A4%87%E4%BC%A0%E8%BE%93RDB">原文位置：syncWithMaster</a>。</p><p><strong>作者论述（转述）：</strong>作者介绍安装 RDB 读取回调、进入传输状态后，说该字段设为正一；紧接着贴出的初始化代码实际是负一。</p><p><strong>对应源码，2020 快照：</strong><a href="/path/to/redis/redis-c01e94a-2020-08/src/replication.c:2384">replication.c:2384</a>：</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line">server.repl_state = REPL_STATE_TRANSFER;</span><br><span class="line">server.repl_transfer_size = <span class="number">-1</span>;</span><br><span class="line">server.repl_transfer_read = <span class="number">0</span>;</span><br><span class="line">server.repl_transfer_last_fsync_off = <span class="number">0</span>;</span><br><span class="line">server.repl_transfer_lastio = server.unixtime;</span><br></pre></td></tr></table></figure><p>接收回调据此判断是否读取协议头，<a href="/path/to/redis/redis-c01e94a-2020-08/src/replication.c:1493">replication.c:1493</a>：</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment">/* If repl_transfer_size == -1 we still have to read the bulk length</span></span><br><span class="line"><span class="comment"> * from the master reply. */</span></span><br><span class="line"><span class="keyword">if</span> (server.repl_transfer_size == <span class="number">-1</span>) &#123;</span><br><span class="line">    <span class="keyword">if</span> (connSyncReadLine(conn,buf,<span class="number">1024</span>,server.repl_syncio_timeout*<span class="number">1000</span>) == <span class="number">-1</span>) &#123;</span><br></pre></td></tr></table></figure><p>2018 快照初始化同样为 -1，见 <a href="/path/to/redis/redis-unstable-2018-07-23/src/replication.c:1841">replication.c:1841</a>。</p><p><strong>为何不对：</strong>这应归为<strong>正文笔误，与其紧随的源码自相矛盾</strong>。这里的负号有协议含义：-1 是尚未解析长度/EOF 传输头的哨兵值。首轮回调先读取 <code>$&lt;长度&gt;</code> 或 <code>$EOF:&lt;标记&gt;</code>，然后才接收 RDB 数据。若照正文把它理解成 1，就会把“长度尚未知”误读为“长度已确定为 1 字节”，漏掉正确的接收状态转换。</p><h2 id="3-CAPA-发送的是协议能力，不是容量"><a href="#3-CAPA-发送的是协议能力，不是容量" class="headerlink" title="3. CAPA 发送的是协议能力，不是容量"></a>3. CAPA 发送的是协议能力，不是容量</h2><p><strong>作者原文摘录（节选）：</strong></p><blockquote><p>用来发送Slave的容量</p></blockquote><p><a href="https://www.calvinneo.com/2021/05/15/redis-replication/#syncWithMaster-%E6%8F%A1%E6%89%8B%E4%BB%A5%E5%8F%8A%E5%87%86%E5%A4%87%E4%BC%A0%E8%BE%93RDB">原文位置：syncWithMaster</a>。</p><p><strong>作者论述（转述）：</strong>作者把 <code>REPL_STATE_SEND_CAPA</code> 解释为发送从库容量，并追问该容量的含义；随附注释说明的是 EOF、PSYNC2 协议能力。</p><p><strong>对应源码，2020 快照：</strong><a href="/path/to/redis/redis-c01e94a-2020-08/src/replication.c:2272">replication.c:2272</a>：</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">if</span> (server.repl_state == REPL_STATE_SEND_CAPA) &#123;</span><br><span class="line">    err = sendSynchronousCommand(SYNC_CMD_WRITE,conn,<span class="string">"REPLCONF"</span>,</span><br><span class="line">            <span class="string">"capa"</span>,<span class="string">"eof"</span>,<span class="string">"capa"</span>,<span class="string">"psync2"</span>,<span class="literal">NULL</span>);</span><br></pre></td></tr></table></figure><p>主库解析为能力位，<a href="/path/to/redis/redis-c01e94a-2020-08/src/replication.c:893">replication.c:893</a>：</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line">&#125; <span class="keyword">else</span> <span class="keyword">if</span> (!strcasecmp(c-&gt;argv[j]-&gt;ptr,<span class="string">"capa"</span>)) &#123;</span><br><span class="line">    <span class="comment">/* Ignore capabilities not understood by this master. */</span></span><br><span class="line">    <span class="keyword">if</span> (!strcasecmp(c-&gt;argv[j+<span class="number">1</span>]-&gt;ptr,<span class="string">"eof"</span>))</span><br><span class="line">        c-&gt;slave_capa |= SLAVE_CAPA_EOF;</span><br><span class="line">    <span class="keyword">else</span> <span class="keyword">if</span> (!strcasecmp(c-&gt;argv[j+<span class="number">1</span>]-&gt;ptr,<span class="string">"psync2"</span>))</span><br><span class="line">        c-&gt;slave_capa |= SLAVE_CAPA_PSYNC2;</span><br></pre></td></tr></table></figure><p>2018 快照发送相同的能力声明，见 <a href="/path/to/redis/redis-unstable-2018-07-23/src/replication.c:1739">replication.c:1739</a>。</p><p><strong>为何欠妥：</strong>这是将 capabilities 误译成 capacity。<code>eof</code> 表示支持用 EOF 标记界定 RDB 传输结尾，<code>psync2</code> 表示支持 PSYNC v2，包括识别 <code>+CONTINUE</code> 中的新复制 ID；该步骤不传输内存、磁盘空间或数据容量。它属于术语错误，但会影响读者对握手时在协商什么的理解。</p><hr><h1 id="Redis基础机制分析"><a href="#Redis基础机制分析" class="headerlink" title="Redis基础机制分析"></a>Redis基础机制分析</h1><p>原文：<a href="https://www.calvinneo.com/2022/10/15/redis-common/">《Redis基础机制分析》</a>。以下均核对本地 **Redis 2020-08 快照 <code>c01e94a4319c416c4c231ffbea9e778d52424e30</code>**，目录为 <code>redis-c01e94a-2020-08</code>。这里用提交号识别版本，不把开发快照当作某个正式发行版。原文摘录仅保留定位问题的短语，后面的“作者论述（转述）”不是逐字引文。</p><h2 id="1-Lua-脚本固定过期判断时间，并没有全面禁止过期"><a href="#1-Lua-脚本固定过期判断时间，并没有全面禁止过期" class="headerlink" title="1. Lua 脚本固定过期判断时间，并没有全面禁止过期"></a>1. Lua 脚本固定过期判断时间，并没有全面禁止过期</h2><p><strong>作者原文摘录（节选）：</strong></p><blockquote><p>要禁止expire</p></blockquote><p><a href="https://www.calvinneo.com/2022/10/15/redis-common/#keyIsExpired">原文位置：keyIsExpired</a></p><p><strong>作者论述（转述）：</strong>作者为解释主从及 AOF 执行结果一致，将冻结时钟说成脚本内不再过期，并认为应先清理脚本涉及的键再执行。</p><p><strong>对应源码（2020-08，<code>c01e94a</code>）：</strong><a href="/path/to/redis/redis-c01e94a-2020-08/src/db.c:1232">src/db.c:1232</a>，以下为同一个函数内的三个节选。</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">keyIsExpired</span><span class="params">(redisDb *db, robj *key)</span> </span>&#123;</span><br><span class="line">    <span class="keyword">mstime_t</span> when = getExpire(db,key);</span><br><span class="line">    <span class="keyword">mstime_t</span> now;</span><br><span class="line"></span><br><span class="line">    <span class="keyword">if</span> (when &lt; <span class="number">0</span>) <span class="keyword">return</span> <span class="number">0</span>; <span class="comment">/* No expire for this key */</span></span><br><span class="line"></span><br><span class="line">    <span class="comment">/* Don't expire anything while loading. It will be done later. */</span></span><br><span class="line">    <span class="keyword">if</span> (server.loading) <span class="keyword">return</span> <span class="number">0</span>;</span><br></pre></td></tr></table></figure><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">if</span> (server.lua_caller) &#123;</span><br><span class="line">    now = server.lua_time_start;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">return</span> now &gt; when;</span><br></pre></td></tr></table></figure><p>主节点收到过期判断后，仍然执行删除：<a href="/path/to/redis/redis-c01e94a-2020-08/src/db.c:1288">src/db.c:1288</a>、<a href="/path/to/redis/redis-c01e94a-2020-08/src/db.c:1299">src/db.c:1299</a>。</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">expireIfNeeded</span><span class="params">(redisDb *db, robj *key)</span> </span>&#123;</span><br><span class="line">    <span class="keyword">if</span> (!keyIsExpired(db,key)) <span class="keyword">return</span> <span class="number">0</span>;</span><br></pre></td></tr></table></figure><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">if</span> (server.masterhost != <span class="literal">NULL</span>) <span class="keyword">return</span> <span class="number">1</span>;</span><br><span class="line"></span><br><span class="line"><span class="comment">/* Delete the key */</span></span><br><span class="line">server.stat_expiredkeys++;</span><br><span class="line">propagateExpire(db,key,server.lazyfree_lazy_expire);</span><br><span class="line">notifyKeyspaceEvent(NOTIFY_EXPIRED,</span><br><span class="line">    <span class="string">"expired"</span>,key,db-&gt;id);</span><br><span class="line"><span class="keyword">int</span> retval = server.lazyfree_lazy_expire ? dbAsyncDelete(db,key) :</span><br><span class="line">                                           dbSyncDelete(db,key);</span><br></pre></td></tr></table></figure><p><strong>为什么不准确：</strong>假设键的过期时间是 900 ms，脚本从 1000 ms 开始。脚本第一次访问该键时，比较结果仍然是 <code>1000 &gt; 900</code>，主节点会在这次访问中删除它。被固定的是判断用的时钟，所以在脚本开始时尚未到期的键，不会仅仅因为脚本耗时而在后续访问中突然过期。</p><p><code>evalGenericCommand</code> 设置 <code>server.lua_time_start</code> 后调用 <code>lua_pcall</code>，并没有在进入脚本之前遍历 <code>KEYS</code> 统一执行 <code>expireIfNeeded</code>；参见 <a href="/path/to/redis/redis-c01e94a-2020-08/src/scripting.c:1541">src/scripting.c:1541</a>。因此，更准确的表述是：<strong>在脚本内按脚本开始时刻进行惰性过期判断；首次访问仍可能触发过期删除。</strong></p><h2 id="2-FAST-过期循环不是根据键少而选用的模式"><a href="#2-FAST-过期循环不是根据键少而选用的模式" class="headerlink" title="2. FAST 过期循环不是根据键少而选用的模式"></a>2. FAST 过期循环不是根据键少而选用的模式</h2><p><strong>作者原文摘录（节选）：</strong></p><blockquote><p>key比较少</p></blockquote><p><a href="https://www.calvinneo.com/2022/10/15/redis-common/#%E4%B8%BB%E5%8A%A8expire%E5%AE%9E%E7%8E%B0">原文位置：主动expire实现</a></p><p><strong>作者论述（转述）：</strong>作者将两种循环按清理强度区分：FAST 用于键少时节省 CPU，过期键数量降至阈值便退出；SLOW 更积极地回收内存。</p><p><strong>对应源码（2020-08，<code>c01e94a</code>）：</strong><a href="/path/to/redis/redis-c01e94a-2020-08/src/expire.c:153">src/expire.c:153</a>。</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">if</span> (type == ACTIVE_EXPIRE_CYCLE_FAST) &#123;</span><br><span class="line">    <span class="comment">/* Don't start a fast cycle if the previous cycle did not exit</span></span><br><span class="line"><span class="comment">     * for time limit, unless the percentage of estimated stale keys is</span></span><br><span class="line"><span class="comment">     * too high. Also never repeat a fast cycle for the same period</span></span><br><span class="line"><span class="comment">     * as the fast cycle total duration itself. */</span></span><br><span class="line">    <span class="keyword">if</span> (!timelimit_exit &amp;&amp;</span><br><span class="line">        server.stat_expired_stale_perc &lt; config_cycle_acceptable_stale)</span><br><span class="line">        <span class="keyword">return</span>;</span><br><span class="line"></span><br><span class="line">    <span class="keyword">if</span> (start &lt; last_fast_cycle + (<span class="keyword">long</span> <span class="keyword">long</span>)config_cycle_fast_duration*<span class="number">2</span>)</span><br><span class="line">        <span class="keyword">return</span>;</span><br><span class="line"></span><br><span class="line">    last_fast_cycle = start;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure><p>调用地点分别是 <code>databasesCron</code> 和 <code>beforeSleep</code>：<a href="/path/to/redis/redis-c01e94a-2020-08/src/server.c:1706">src/server.c:1706</a>、<a href="/path/to/redis/redis-c01e94a-2020-08/src/server.c:2184">src/server.c:2184</a>。</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">if</span> (server.active_expire_enabled) &#123;</span><br><span class="line">    <span class="keyword">if</span> (iAmMaster()) &#123;</span><br><span class="line">        activeExpireCycle(ACTIVE_EXPIRE_CYCLE_SLOW);</span><br><span class="line">    &#125; <span class="keyword">else</span> &#123;</span><br><span class="line">        expireSlaveKeys();</span><br><span class="line">    &#125;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">if</span> (server.active_expire_enabled &amp;&amp; server.masterhost == <span class="literal">NULL</span>)</span><br><span class="line">    activeExpireCycle(ACTIVE_EXPIRE_CYCLE_FAST);</span><br></pre></td></tr></table></figure><p><strong>为什么不准确：</strong>这不是按键数量二选一的策略。SLOW 是定时维护中的常规循环；FAST 是事件循环中的补充清理机会，其入口受前次是否超时、过期统计量及距上次 FAST 的间隔约束。低清理压力下 FAST 反而可能直接返回。两者共用同一套扫描主体，主要差别是调用时机和时间预算：默认 FAST 为约 1 ms，SLOW 为 <code>25% / server.hz</code> 秒，参见 <a href="/path/to/redis/redis-c01e94a-2020-08/src/expire.c:117">src/expire.c:117</a>、<a href="/path/to/redis/redis-c01e94a-2020-08/src/expire.c:182">src/expire.c:182</a>。这些是预算与定期检查机制，不能理解为每次调用绝不会超出的硬实时上限。</p><h2 id="3-把-SYNC-PSYNC-概括成全量同步，遗漏了-PSYNC-的核心分支"><a href="#3-把-SYNC-PSYNC-概括成全量同步，遗漏了-PSYNC-的核心分支" class="headerlink" title="3. 把 SYNC / PSYNC 概括成全量同步，遗漏了 PSYNC 的核心分支"></a>3. 把 SYNC / PSYNC 概括成全量同步，遗漏了 PSYNC 的核心分支</h2><p><strong>作者原文摘录（节选）：</strong></p><blockquote><p>来个全量同步</p></blockquote><p><a href="https://www.calvinneo.com/2022/10/15/redis-common/#propagate%E6%9C%BA%E5%88%B6">原文位置：propagate机制</a></p><p><strong>作者论述（转述）：</strong>作者把复制分为状态同步和指令传播：SYNC/PSYNC 开始时全量同步主节点状态，propagate 则把后续指令发送给从节点或 AOF。</p><p><strong>对应源码（2020-08，<code>c01e94a</code>）：</strong><a href="/path/to/redis/redis-c01e94a-2020-08/src/replication.c:743">src/replication.c:743</a>。</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">if</span> (!strcasecmp(c-&gt;argv[<span class="number">0</span>]-&gt;ptr,<span class="string">"psync"</span>)) &#123;</span><br><span class="line">    <span class="keyword">if</span> (masterTryPartialResynchronization(c) == C_OK) &#123;</span><br><span class="line">        server.stat_sync_partial_ok++;</span><br><span class="line">        <span class="keyword">return</span>; <span class="comment">/* No full resync needed, return. */</span></span><br></pre></td></tr></table></figure><p>部分同步接受后会回复 <code>CONTINUE</code> 并发送 backlog：<a href="/path/to/redis/redis-c01e94a-2020-08/src/replication.c:585">src/replication.c:585</a>。</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">if</span> (c-&gt;slave_capa &amp; SLAVE_CAPA_PSYNC2) &#123;</span><br><span class="line">    buflen = <span class="built_in">snprintf</span>(buf,<span class="keyword">sizeof</span>(buf),<span class="string">"+CONTINUE %s\r\n"</span>, server.replid);</span><br><span class="line">&#125; <span class="keyword">else</span> &#123;</span><br><span class="line">    buflen = <span class="built_in">snprintf</span>(buf,<span class="keyword">sizeof</span>(buf),<span class="string">"+CONTINUE\r\n"</span>);</span><br><span class="line">&#125;</span><br><span class="line"><span class="keyword">if</span> (connWrite(c-&gt;conn,buf,buflen) != buflen) &#123;</span><br><span class="line">    freeClientAsync(c);</span><br><span class="line">    <span class="keyword">return</span> C_OK;</span><br><span class="line">&#125;</span><br><span class="line">psync_len = addReplyReplicationBacklog(c,psync_offset);</span><br></pre></td></tr></table></figure><p><strong>为什么欠妥：</strong>首次连接且没有可续传历史时，确实通常需要全量同步。但 <code>PSYNC</code> 还用于断线后的部分重同步：复制 ID 可接受，而且请求的 offset 仍在 backlog 覆盖范围内时，只补传缺失的复制流，不重新发送整个数据库。对应检查见 <a href="/path/to/redis/redis-c01e94a-2020-08/src/replication.c:534">src/replication.c:534</a>、<a href="/path/to/redis/redis-c01e94a-2020-08/src/replication.c:559">src/replication.c:559</a>。应分别说明 <strong>SYNC 的全量同步，以及 PSYNC 的部分同步／退回全量同步</strong>，否则读者容易误判复制重连的代价。</p><h2 id="4-LFU-计数器与访问次数并非严格的对数关系"><a href="#4-LFU-计数器与访问次数并非严格的对数关系" class="headerlink" title="4. LFU 计数器与访问次数并非严格的对数关系"></a>4. LFU 计数器与访问次数并非严格的对数关系</h2><p><strong>作者原文摘录（节选）：</strong></p><blockquote><p>成对数关系</p></blockquote><p><a href="https://www.calvinneo.com/2022/10/15/redis-common/#%E5%A2%9E%E5%8A%A0counter">原文位置：增加counter</a></p><p><strong>作者论述（转述）：</strong>作者由计数越大、增长概率越低推论其与访问数呈对数关系，称调大因子能记录更高频次，并认为随机性使数学计算困难。</p><p><strong>对应源码（2020-08，<code>c01e94a</code>）：</strong><a href="/path/to/redis/redis-c01e94a-2020-08/src/evict.c:315">src/evict.c:315</a>。</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">uint8_t</span> LFULogIncr(<span class="keyword">uint8_t</span> counter) &#123;</span><br><span class="line">    <span class="keyword">if</span> (counter == <span class="number">255</span>) <span class="keyword">return</span> <span class="number">255</span>;</span><br><span class="line">    <span class="keyword">double</span> r = (<span class="keyword">double</span>)rand()/RAND_MAX;</span><br><span class="line">    <span class="keyword">double</span> baseval = counter - LFU_INIT_VAL;</span><br><span class="line">    <span class="keyword">if</span> (baseval &lt; <span class="number">0</span>) baseval = <span class="number">0</span>;</span><br><span class="line">    <span class="keyword">double</span> p = <span class="number">1.0</span>/(baseval*server.lfu_log_factor+<span class="number">1</span>);</span><br><span class="line">    <span class="keyword">if</span> (r &lt; p) counter++;</span><br><span class="line">    <span class="keyword">return</span> counter;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure><p><strong>为什么不准确：</strong>忽略衰减、饱和以及伪随机数离散化，令 <code>f = lfu_log_factor</code>，<code>b = counter - LFU_INIT_VAL ≥ 0</code>。在计数值固定时，每次命中使其增加的概率为 <code>1 / (f*b + 1)</code>，所以等到下一次增加所需命中次数的期望是 <code>f*b + 1</code>。从初始值增加 <code>m</code> 次的总命中次数期望为：</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">E[N_m] = Σ(b=0…m−1) (f*b + 1)</span><br><span class="line">       = m + f*m*(m−1)/2</span><br></pre></td></tr></table></figure><p>当 <code>f &gt; 0</code> 时，这是关于 <code>m</code> 的二次式，其反函数呈平方根量级；<code>f = 0</code> 时则近似每次命中都增加，直到饱和。因此，应说它是<strong>增长概率随当前值减小的压缩计数器</strong>，不能由函数名 <code>LFULogIncr</code> 推出严格的对数关系。源码注释自身也使用了 “Logarithmically” 这个词，但具体的数学关系仍应以函数内的概率公式为准。</p><h2 id="5-DEL-不会无条件发布两条键通知"><a href="#5-DEL-不会无条件发布两条键通知" class="headerlink" title="5. DEL 不会无条件发布两条键通知"></a>5. DEL 不会无条件发布两条键通知</h2><p><strong>作者原文摘录（节选）：</strong></p><blockquote><p>分发两条消息</p></blockquote><p><a href="https://www.calvinneo.com/2022/10/15/redis-common/#notifyKeyspaceEvent">原文位置：notifyKeyspaceEvent</a></p><p><strong>作者论述（转述）：</strong>作者以在零号数据库对 <code>mykey</code> 执行 DEL 为例，称两个频道会同时发送通知，分别告知该键发生的事件及执行删除命令的键。</p><p><strong>对应源码（2020-08，<code>c01e94a</code>）：</strong><a href="/path/to/redis/redis-c01e94a-2020-08/src/notify.c:111">src/notify.c:111</a>。</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment">/* If notifications for this class of events are off, return ASAP. */</span></span><br><span class="line"><span class="keyword">if</span> (!(server.notify_keyspace_events &amp; type)) <span class="keyword">return</span>;</span><br><span class="line"></span><br><span class="line">eventobj = createStringObject(event,<span class="built_in">strlen</span>(event));</span><br><span class="line"></span><br><span class="line"><span class="comment">/* __keyspace@&lt;db&gt;__:&lt;key&gt; &lt;event&gt; notifications. */</span></span><br><span class="line"><span class="keyword">if</span> (server.notify_keyspace_events &amp; NOTIFY_KEYSPACE) &#123;</span><br></pre></td></tr></table></figure><p>第二个频道有独立开关：<a href="/path/to/redis/redis-c01e94a-2020-08/src/notify.c:129">src/notify.c:129</a>。</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">if</span> (server.notify_keyspace_events &amp; NOTIFY_KEYEVENT) &#123;</span><br></pre></td></tr></table></figure><p>DEL 也仅在确实删除成功时触发 <code>del</code> 事件：<a href="/path/to/redis/redis-c01e94a-2020-08/src/db.c:562">src/db.c:562</a>。</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">for</span> (j = <span class="number">1</span>; j &lt; c-&gt;argc; j++) &#123;</span><br><span class="line">    expireIfNeeded(c-&gt;db,c-&gt;argv[j]);</span><br><span class="line">    <span class="keyword">int</span> deleted  = lazy ? dbAsyncDelete(c-&gt;db,c-&gt;argv[j]) :</span><br><span class="line">                          dbSyncDelete(c-&gt;db,c-&gt;argv[j]);</span><br><span class="line">    <span class="keyword">if</span> (deleted) &#123;</span><br><span class="line">        signalModifiedKey(c,c-&gt;db,c-&gt;argv[j]);</span><br><span class="line">        notifyKeyspaceEvent(NOTIFY_GENERIC,</span><br><span class="line">            <span class="string">"del"</span>,c-&gt;argv[j],c-&gt;db-&gt;id);</span><br></pre></td></tr></table></figure><p><strong>为什么欠妥：</strong>默认 <code>server.notify_keyspace_events = 0</code>，见 <a href="/path/to/redis/redis-c01e94a-2020-08/src/server.c:2405">src/server.c:2405</a>，所以默认不会发布文中这两条 Pub/Sub 消息。只有同时开启通用事件类别 <code>g</code>、keyspace 频道 <code>K</code>、keyevent 频道 <code>E</code>，例如设置 <code>notify-keyspace-events KEg</code>，而且该键被真正删除，例子才成立。删除不存在的键不会产生 <code>del</code> 通知；过期键若先被 <code>expireIfNeeded</code> 清理，则走的是 <code>expired</code> 事件。模块通知另有通道，不受这一 Pub/Sub 配置判断控制。</p><h2 id="6-HAVE-MALLOC-SIZE-不会关闭内存统计"><a href="#6-HAVE-MALLOC-SIZE-不会关闭内存统计" class="headerlink" title="6. HAVE_MALLOC_SIZE 不会关闭内存统计"></a>6. HAVE_MALLOC_SIZE 不会关闭内存统计</h2><p><strong>作者原文摘录（节选）：</strong></p><blockquote><p>通过HAVE_MALLOC_SIZE禁用内存统计的功能</p></blockquote><p><a href="https://www.calvinneo.com/2022/10/15/redis-common/#Redis%E5%86%85%E5%AD%98%E7%AE%A1%E7%90%86zmalloc">原文位置：Redis内存管理zmalloc</a></p><p><strong>作者论述（转述）：</strong>作者先说明 zmalloc 增加长度前缀、返回偏移后的指针，再认为定义 HAVE_MALLOC_SIZE 就能省去这部分记录并停用内存统计。</p><p><strong>对应源码（2020-08，<code>c01e94a</code>）：</strong><a href="/path/to/redis/redis-c01e94a-2020-08/src/zmalloc.c:89">src/zmalloc.c:89</a>。</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="keyword">void</span> *<span class="title">zmalloc</span><span class="params">(<span class="keyword">size_t</span> size)</span> </span>&#123;</span><br><span class="line">    <span class="keyword">void</span> *ptr = <span class="built_in">malloc</span>(size+PREFIX_SIZE);</span><br><span class="line"></span><br><span class="line">    <span class="keyword">if</span> (!ptr) zmalloc_oom_handler(size);</span><br><span class="line"><span class="meta">#<span class="meta-keyword">ifdef</span> HAVE_MALLOC_SIZE</span></span><br><span class="line">    update_zmalloc_stat_alloc(zmalloc_size(ptr));</span><br><span class="line">    <span class="keyword">return</span> ptr;</span><br><span class="line"><span class="meta">#<span class="meta-keyword">else</span></span></span><br><span class="line">    *((<span class="keyword">size_t</span>*)ptr) = size;</span><br><span class="line">    update_zmalloc_stat_alloc(size+PREFIX_SIZE);</span><br><span class="line">    <span class="keyword">return</span> (<span class="keyword">char</span>*)ptr+PREFIX_SIZE;</span><br><span class="line"><span class="meta">#<span class="meta-keyword">endif</span></span></span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure><p>统计宏对两个分支相同：<a href="/path/to/redis/redis-c01e94a-2020-08/src/zmalloc.c:74">src/zmalloc.c:74</a>。</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line"><span class="meta">#<span class="meta-keyword">define</span> update_zmalloc_stat_alloc(__n) atomicIncr(used_memory,(__n))</span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">define</span> update_zmalloc_stat_free(__n) atomicDecr(used_memory,(__n))</span></span><br></pre></td></tr></table></figure><p><strong>为什么错误：</strong>两个分支都更新 <code>used_memory</code>。<code>HAVE_MALLOC_SIZE</code> 表示当前分配器可以查询已分配块的大小，因此 Redis 不必在返回给调用者的内存前额外存储长度。以 macOS 为例，<a href="/path/to/redis/redis-c01e94a-2020-08/src/zmalloc.h:58">src/zmalloc.h:58</a> 把 <code>zmalloc_size(p)</code> 映射到系统的 <code>malloc_size(p)</code>。关闭的是 Redis 自己添加的长度前缀，内存统计仍然有效；有分配器大小接口时，统计依据还可以反映分配器实际提供的块大小。</p>]]></content>
    
    
    <summary type="html">&lt;p&gt;核查日期：2026-09-22。使用 chatgpt 6 修订该站 Redis 标签下的六篇文章。&lt;/p&gt;
&lt;p&gt;本地版本依据实际 Git HEAD 确认：&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;本文简称&lt;/th&gt;
&lt;th&gt;本地源码&lt;/th&gt;
&lt;th&gt;固定提交&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;&lt;tr&gt;
&lt;td&gt;2018 快照&lt;/td&gt;
&lt;td&gt;redis-unstable-2018-07-23&lt;/td&gt;
&lt;td&gt;&lt;a href=&quot;https://github.com/redis/redis/commit/b65ddfb16a7060a543b523feadeca1234cffd323&quot; target=&quot;_blank&quot; rel=&quot;noopener&quot;&gt;&lt;code&gt;b65ddfb16a7060a543b523feadeca1234cffd323&lt;/code&gt;&lt;/a&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;2020 快照&lt;/td&gt;
&lt;td&gt;redis-c01e94a-2020-08&lt;/td&gt;
&lt;td&gt;&lt;a href=&quot;https://github.com/redis/redis/commit/c01e94a4319c416c4c231ffbea9e778d52424e30&quot; target=&quot;_blank&quot; rel=&quot;noopener&quot;&gt;&lt;code&gt;c01e94a4319c416c4c231ffbea9e778d52424e30&lt;/code&gt;&lt;/a&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;&lt;/table&gt;
&lt;p&gt;二者均为 unstable 开发快照，不直接等同于 Redis 5.0 / 6.0 正式版。对象篇的 dict 分析使用 2018 快照，其余主要使用作者明确链接的 2020 快照；涉及跨版本结论的地方另行标注。&lt;/p&gt;</summary>
    
    
    
    
    <category term="AIGen" scheme="http://www.calvinneo.com/tags/AIGen/"/>
    
    <category term="数据库" scheme="http://www.calvinneo.com/tags/数据库/"/>
    
    <category term="redis" scheme="http://www.calvinneo.com/tags/redis/"/>
    
  </entry>
  
  <entry>
    <title>RDMA 学习</title>
    <link href="http://www.calvinneo.com/2026/09/20/rdma-learn/"/>
    <id>http://www.calvinneo.com/2026/09/20/rdma-learn/</id>
    <published>2026-09-20T14:48:32.000Z</published>
    <updated>2026-10-19T15:29:03.920Z</updated>
    
    <content type="html"><![CDATA[<p>围绕一次 RDMA Write，整理资源与地址、请求提交、完成队列以及驱动分工。重点区分请求提交成功、设备完成、远端得知数据到达，以及业务已经消费数据这几个时刻。</p><a id="more"></a><h1 id="基本概念"><a href="#基本概念" class="headerlink" title="基本概念"></a>基本概念</h1><p><strong>RDMA（Remote Direct Memory Access，远程直接内存访问）</strong>允许网络适配器在已建立的映射和权限范围内，直接访问另一台主机的内存。以 RDMA Write 为例，发起端指定远端地址和访问密钥，接收端的网卡完成数据放置，不需要接收端 CPU 为每次写入执行一遍接收和复制。这不表示整个系统不再需要 CPU，资源建立、提交请求和消费数据仍然有软件参与。</p><p><strong>verbs</strong> 是 RDMA 软件栈提供的资源管理与工作请求接口，Linux 用户态常用的设备无关接口库是 <code>libibverbs</code>。设备相关的用户态库负责实现这些接口，称为 <strong>provider</strong>。<strong>InfiniBand（IB）</strong>是包含链路、网络和传输机制的互联标准，原生支持 RDMA，并不是某一家厂商的私有协议。<strong>RoCE（RDMA over Converged Ethernet）</strong>则把 RDMA 传输放到以太网上。RoCEv1 使用以太网封装，RoCEv2 使用 UDP/IP 封装，能够经过 IP 路由。<a href="https://networking-docs.nvidia.com/doca/archive/3-5-0/rdma-aware-networks-programming-guide" target="_blank" rel="noopener">RDMA 编程指南</a>和 <a href="https://docs.nvidia.com/networking/display/mlnxenv24101140lts/rdma+over+converged+ethernet+(roce)" target="_blank" rel="noopener">RoCE 文档</a>分别介绍了这些层次。</p><p>下文沿用 A 向 B 写数据的例子，两端使用 <strong>RC（Reliable Connection，可靠连接）</strong>：通信端点一对一配对，设备执行协议确认、顺序控制和重试。可靠不等于任何故障下都能成功，重试耗尽等情况仍会使请求失败。请求与完成的主线先限定在普通主机内存，GPU 的同步条件放在补充部分。</p><h2 id="内存、队列与保护域"><a href="#内存、队列与保护域" class="headerlink" title="内存、队列与保护域"></a>内存、队列与保护域</h2><p>打开 RDMA 设备会得到 <code>ibv_context</code>，它代表应用对某个 RDMA 设备的访问上下文。设备可以暴露多个端口，设备对象也不一定与物理网卡一一对应。RDMA 资料中的 <strong>HCA（Host Channel Adapter，主机通道适配器）</strong>指主机侧的适配器，下文统称网卡。</p><p>A 分配了 <code>a_buffer</code>，B 分配了 <code>b_buffer</code>，还需要把这两段内存注册成 <strong>MR（Memory Region，内存区域）</strong>。MR 描述设备可访问的地址范围、映射和权限。注册不是复制数据，也不要求这段虚拟地址对应的物理页连续。注册结果中的 <code>lkey</code> 用于本端请求访问本地 MR，<code>rkey</code> 则用于远端发起的 RDMA 访问。B 把地址和 <code>rkey</code> 告诉 A 后，A 才有了描述远端目标所需的信息。<a href="https://github.com/linux-rdma/rdma-core/blob/v59.0/libibverbs/man/ibv_reg_mr.3" target="_blank" rel="noopener"><code>ibv_reg_mr()</code></a></p><p><strong>QP（Queue Pair，队列对）</strong>是应用提交通信工作的对象，在 RC 中，一个 QP 与远端的一个 QP 配对。这里使用的普通 QP 包含发送工作队列 <strong>SQ（Send Queue）</strong>和接收工作队列 <strong>RQ（Receive Queue）</strong>。应用提交的工作描述叫 <strong>WR（Work Request，工作请求）</strong>。SQ 接受本端发起的工作，除了 Write，还可以是把远端内容读到本地的 <strong>RDMA Read</strong>，或由对端接收请求决定数据落点的 <strong>SEND</strong>。所以 <code>ibv_post_send()</code>名字里的 send 表示向 SQ 提交，并不只指 SEND 操作。</p><p>RQ 中放置预先提交的 Receive WR，供 SEND 等需要接收资源的操作使用。在 RC 中，需要接收资源的请求到达时，如果没有可匹配的 Receive WR，就会得到 <strong>RNR（Receiver Not Ready，接收端未就绪）</strong>响应。普通 Write 不依赖这类接收资源，具体区别在后文展开。</p><p><strong>PD（Protection Domain，保护域）</strong>把 MR、QP 等资源组织在同一套本地访问保护关系中。本例中，A 的 QP 与它使用的本地 MR 属于同一个 PD，B 接受写入的 QP 与目标 MR 也属于同一个 PD。两台机器的 PD 是各自创建的对象，不需要有相同的编号。对普通 Write，B 的目标 MR 要允许远端写，注册时还必须同时允许本地写，接收该访问的 QP 也要开启相应权限。<a href="https://github.com/linux-rdma/rdma-core/blob/v59.0/libibverbs/man/ibv_reg_mr.3" target="_blank" rel="noopener">内存注册</a>与 <a href="https://github.com/linux-rdma/rdma-core/blob/v59.0/libibverbs/man/ibv_modify_qp.3" target="_blank" rel="noopener">QP 属性</a>分别控制这两层授权。</p><p>执行结果放在 <strong>CQ（Completion Queue，完成队列）</strong>。创建 QP 时，<code>send_cq</code> 和 <code>recv_cq</code> 分别指定发送侧和接收侧使用的 CQ，它们可以是同一个 CQ，多个 QP 也可以共享 CQ。CQ 关联到设备上下文，不属于某个 PD，因此同一设备上下文中不同 PD 的 QP 也能共享它。<a href="https://github.com/linux-rdma/rdma-core/blob/v59.0/libibverbs/man/ibv_create_qp.3" target="_blank" rel="noopener"><code>ibv_create_qp()</code></a>接受 PD 和 CQ 参数，<a href="https://github.com/linux-rdma/rdma-core/blob/v59.0/libibverbs/man/ibv_create_cq.3" target="_blank" rel="noopener"><code>ibv_create_cq()</code></a>则没有所属 PD 这个参数。</p><p>下面只画同一进程内的资源关系，PD X/Y 不是两台机器：</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br></pre></td><td class="code"><pre><span class="line">ibv_context</span><br><span class="line">├── PD X</span><br><span class="line">│   ├── MR X</span><br><span class="line">│   └── QP X ──┐</span><br><span class="line">├── PD Y       │</span><br><span class="line">│   ├── MR Y   ├── 完成记录进入 CQ Z</span><br><span class="line">│   └── QP Y ──┘</span><br><span class="line">└── CQ Z</span><br></pre></td></tr></table></figure><h2 id="端口、地址与连接状态"><a href="#端口、地址与连接状态" class="headerlink" title="端口、地址与连接状态"></a>端口、地址与连接状态</h2><p>建连时还需要区分几种标识。<strong>Port</strong> 是 RDMA 设备暴露的物理或逻辑端口，不是 TCP/UDP 端口。<strong>QPN（Queue Pair Number）</strong>是 QP 的编号，在指定远端设备和路径之后用它定位目标 QP。<strong>PSN（Packet Sequence Number）</strong>是传输协议中的包序号，RC 建连时双方交换初始 PSN，使发送端的起始序号与接收端期望的序号匹配。它不是应用请求的编号。</p><p><strong>GID（Global Identifier，全局标识符）</strong>用于标识 RDMA 网络中的端口等对象，IB 和 RoCE 都会用到。在 RoCE 中，GID 表项与网口的 IP 地址及 RoCE 类型关联。<code>ibv_query_gid()</code>读取的是本地端口 GID 表中指定索引的值，选择索引时还要核对网口和 GID 类型，不能只看到地址相同就认为表项等价。<strong>LID（Local Identifier，本地标识符）</strong>则是 IB 子网内用于寻址的标识，由管理该子网拓扑与路径的 Subnet Manager 分配。RoCE 不使用 IB 的这套链路层地址，查询 RoCE 端口时 LID 显示为零，不能把它推广成所有 RDMA 端口的性质。<a href="https://networking-docs.nvidia.com/doca/archive/3-5-0/rdma-aware-networks-programming-guide" target="_blank" rel="noopener">标识符定义</a>、<a href="https://docs.nvidia.com/networking/display/mlnxenv24101140lts/rdma+over+converged+ethernet+(roce)" target="_blank" rel="noopener">RoCE GID 与 LID</a></p><p>普通 RC QP 通过 <code>ibv_modify_qp()</code>经历 <code>RESET → INIT → RTR → RTS</code>。<code>INIT</code> 设置本地端口和访问权限，<code>RTR</code>（Ready to Receive）配置远端 QPN、路径与接收起始 PSN，使 QP 具备接收条件，<code>RTS</code>（Ready to Send）再配置发送起始 PSN、重试等参数，使发送侧可以工作。它们是 QP 的状态转换，TCP 建连本身不会代替这些配置。<a href="https://github.com/linux-rdma/rdma-core/blob/v59.0/libibverbs/man/ibv_modify_qp.3" target="_blank" rel="noopener">接口手册</a>列出了每次转换需要的属性。</p><h2 id="RDMA-Write-的基本链路"><a href="#RDMA-Write-的基本链路" class="headerlink" title="RDMA Write 的基本链路"></a>RDMA Write 的基本链路</h2><p>A 通过 rdma 往 B 写操作的流程，A 大概是：</p><ol><li>通过 ibv_get_device_list、ibv_open_device、ibv_free_device_list 打开设备。</li><li>通过 ibv_query_gid 获得 gid。</li><li>通过 ibv_alloc_pd、ibv_create_cq 创建 pd 和 cq。</li><li>通过 posix_memalign 分配 a_buffer，并把它注册到 pd 中得到一个 mr。</li><li>创建一个 ibv_create_qp，需要指定一个 ibv_qp_init_attr。里面的 max_send_wr 指定了发送队列的深度。</li><li>调用 ibv_modify_qp，让 A 的 QP 从 RESET 到 INIT。</li><li>创建一个控制面的 fd 和套接口，链接到 B，把 A 的 qp 的 qp_num、a_psn、gid_text 发送过去。</li><li>从控制面的 fd 去读 B 的 qpn、psn。gid_text、buffer 的地址和 rkey。</li><li>用这些信息，设置 A 的 ibv_qp_attr，调用 ibv_modify_qp，把状态设置为 RTR。</li><li>用 ibv_modify_qp 把 A 的状态再设置为 RTS。</li><li>从控制面等待 B 也是设置好自己的 QP。</li><li>构造一个 ibv_sge，描述要发送的 buffer。构造一个 ibv_send_wr 封装这个 sge，然后设置 wr.rdma 字段，就是 b 那边的 address 和 rkey。</li><li>调用 ibv_post_send 发送。</li><li>使用一个循环，不停调用 ibv_poll_cq 去查询发送的情况。</li><li>清理：<ol><li>关闭控制面 fd</li><li>销毁 qp、mr、buffer、cq、pd、context。</li></ol></li></ol><p>B 大概是：</p><ol><li>和 A 一样。</li><li>启动控制面，listen 一个地址。</li><li>在 A 链接之后，得到 control_fd。</li><li>先从 control_fd 获得 A 那边的信息。</li><li>然后把自己这边的额信息发送过去。</li><li>用 ibv_modify_qp 切换到 RTR 状态。</li><li>用 ibv_modify_qp 切换到 RTS 状态。</li><li>告诉 A 自己已经 READY 了。</li><li>从控制面直到 A 已经完成了传输。</li><li>调用 <code>__sync_synchronize</code></li><li>发送 OK 给 A。后面就销毁掉。</li></ol><p>控制面的交互大概是：</p><ol><li><p>B 启动 TCP Server</p> <figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">B: listen()</span><br><span class="line">B: accept()</span><br></pre></td></tr></table></figure></li><li><p>A 连接 B</p> <figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">A: connect()</span><br></pre></td></tr></table></figure></li><li><p>A 把自己的 QP 信息发给 B</p> <figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">A -&gt; B:</span><br><span class="line">&lt;a_qpn&gt; &lt;a_psn&gt; &lt;a_gid&gt;</span><br></pre></td></tr></table></figure></li><li><p>B 把自己的 QP 信息和 MR 授权发给 A</p> <figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">B -&gt; A:</span><br><span class="line">&lt;b_qpn&gt; &lt;b_psn&gt; &lt;b_gid&gt; &lt;b_buffer_address&gt; &lt;b_rkey&gt;</span><br></pre></td></tr></table></figure></li><li><p>A 和 B 分别设置自己的 QP</p> <figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">RESET -&gt; INIT -&gt; RTR -&gt; RTS</span><br></pre></td></tr></table></figure></li><li><p>B 告诉 A，B 已经准备完成</p> <figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">B -&gt; A:</span><br><span class="line">READY</span><br></pre></td></tr></table></figure></li><li><p>A 执行一次 RDMA Write</p> <figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">A buffer --RDMA Write--&gt; B buffer</span><br></pre></td></tr></table></figure><p> A 使用：</p><ul><li>本地 a_buffer、length、a_lkey</li><li>远端 b_buffer_address、b_rkey，目的是能够获得授权写入 B buffer</li></ul></li><li><p>A 轮询 CQ，确认 RDMA Write 完成，然后通知 B</p> <figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">A -&gt; B:</span><br><span class="line">DONE</span><br></pre></td></tr></table></figure></li><li><p>B 检查自己的 buffer，验证成功后回复 A</p> <figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">B -&gt; A:</span><br><span class="line">OK</span><br></pre></td></tr></table></figure></li><li><p>A 和 B 关闭 TCP 连接并清理 RDMA 资源</p></li></ol><p>注意，READY、DONE、OK 是这个 demo 自己定义的控制消息，不是 verbs API。原因是这里是单边语义，B 的 CPU 不参与复制，所以需要控制面协助通知 B 是否已经完成。</p><p>KVCache 的传输用什么语义比较好？单边语义的有几个好处：</p><ul><li>数据直接进入目标 KV Cache 地址，不需要中间接收 buffer。</li><li>目标端不需要为每个数据块调用 ibv_post_recv()。</li><li>目标端不需要持续处理 Receive CQ、补充 Receive WR。</li><li>不会因为 Receive Queue 没有槽位而发生 RNR。</li><li>源端可以把大量 TransferEntry 批量转成 RDMA Write WR。</li><li>目标 CPU 不参与每一次数据搬运，适合大块 GPU/Host 内存复制。</li></ul><h1 id="请求提交与完成"><a href="#请求提交与完成" class="headerlink" title="请求提交与完成"></a>请求提交与完成</h1><p>前面的链路中，A 调用 <code>ibv_post_send()</code>，随后循环调用 <code>ibv_poll_cq()</code>。这两个调用之间，请求由谁保存、谁执行、谁报告完成，决定了 buffer 什么时候能复用，也决定了没有完成时应该检查哪一层。</p><p>下面仍然只看 A 向 B 的一次普通 Write。连接和注册已经完成，<code>a_buffer</code> 是源，<code>b_buffer_address</code> 和 <code>b_rkey</code> 来自控制协议。网卡需要从注册的源缓冲读取数据，数据长度在 MR 范围及设备支持范围内。用户态实现部分以 <strong>rdma-core v59.0 的 mlx5 provider</strong> 为核对版本，版本号用于限定源码，不代表业务环境使用这个版本。</p><h2 id="WR-与-WQE"><a href="#WR-与-WQE" class="headerlink" title="WR 与 WQE"></a>WR 与 WQE</h2><p>传统发送接口用 <code>struct ibv_send_wr</code> 表示 WR。它描述执行什么操作、本地数据在哪里，以及远端目标是什么。<strong>SGE（Scatter/Gather Element，散布／聚集元素）</strong>描述一段本地缓冲区，包含地址、长度和 <code>lkey</code>。一个 WR 可以引用多个 SGE，本例只有一段连续源数据，因此 <code>num_sge</code> 设为 <code>1</code>，并不是某个经验调优值。</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br></pre></td><td class="code"><pre><span class="line"><span class="class"><span class="keyword">struct</span> <span class="title">ibv_sge</span> <span class="title">sge</span> = &#123;</span></span><br><span class="line">    .addr = (<span class="keyword">uintptr_t</span>)a_buffer,</span><br><span class="line">    .length = length,</span><br><span class="line">    .lkey = a_mr-&gt;lkey,</span><br><span class="line">&#125;;</span><br><span class="line"></span><br><span class="line"><span class="class"><span class="keyword">struct</span> <span class="title">ibv_send_wr</span> <span class="title">wr</span> = &#123;</span><span class="number">0</span>&#125;;</span><br><span class="line">wr.wr_id = request_id;</span><br><span class="line">wr.sg_list = &amp;sge;</span><br><span class="line">wr.num_sge = <span class="number">1</span>;</span><br><span class="line">wr.opcode = IBV_WR_RDMA_WRITE;</span><br><span class="line">wr.send_flags = IBV_SEND_SIGNALED;</span><br><span class="line">wr.wr.rdma.remote_addr = b_buffer_address;</span><br><span class="line">wr.wr.rdma.rkey = b_rkey;</span><br><span class="line"></span><br><span class="line"><span class="class"><span class="keyword">struct</span> <span class="title">ibv_send_wr</span> *<span class="title">bad_wr</span> = <span class="title">NULL</span>;</span></span><br><span class="line"><span class="keyword">int</span> ret = ibv_post_send(qp, &amp;wr, &amp;bad_wr);</span><br></pre></td></tr></table></figure><p><code>request_id</code> 由应用分配，放在 <code>wr_id</code> 中，用于在完成时找到原请求。这里假设 QP 创建时 <code>sq_sig_all = 0</code>，由每个 WR 选择是否报告正常完成。<code>IBV_SEND_SIGNALED</code> 明确要求本次请求报告完成，否则后面的等待就没有成功完成可取。这里的 signaling 指完成记录的生成，与是否唤醒一个阻塞线程是两件事。</p><p>WR 不直接等于设备执行的队列条目。用户态驱动读取 WR，按网卡格式生成 <strong>WQE（Work Queue Element，工作队列条目）</strong>，写入设备使用的工作队列，再通知网卡有新工作。类似于异步 I/O 的提交描述符，WQE 描述的是一次待执行的工作。一条较大的 Write 会拆成多个网络包，WQE 不能按网络包来理解。</p><p>按照 <a href="https://github.com/linux-rdma/rdma-core/blob/v59.0/libibverbs/man/ibv_post_send.3" target="_blank" rel="noopener"><code>ibv_post_send()</code> 的约定</a>，<code>ret == 0</code> 表示提交成功，非零值是提交阶段检测到的错误码。调用成功返回并不保证网卡已经读完 <code>a_buffer</code>，因此 A 此时还不能改写或释放源数据，也不能撤销相应注册。需要等待的是设备执行完成，不是用户态函数执行完。把源数据内嵌进 WQE 的 inline 方式，以及批量提交的失败边界，放在后面的补充中。</p><h2 id="CQE-与-WC"><a href="#CQE-与-WC" class="headerlink" title="CQE 与 WC"></a>CQE 与 WC</h2><p>设备完成这次 Write 后，把结果写入 QP 的 <code>send_cq</code>。设备格式的完成记录叫 <strong>CQE（Completion Queue Entry，完成队列条目）</strong>。它可以报告成功，也可以报告失败，所以看到完成记录不等于请求成功。</p><p>A 调用 <code>ibv_poll_cq()</code>，用户态驱动读取 CQE，再把设备格式整理成 verbs 接口中的 <strong>WC（Work Completion，工作完成信息）</strong>，通过 <code>struct ibv_wc</code> 返回。CQE 与 WC 描述的是相应的完成结果，但一个是队列中的设备表示，一个是应用接口的表示。</p><p>本例只跟踪一个请求，所以一次最多取一个结果：</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line"><span class="class"><span class="keyword">struct</span> <span class="title">ibv_wc</span> <span class="title">wc</span>;</span></span><br><span class="line"><span class="keyword">int</span> count = ibv_poll_cq(cq, <span class="number">1</span>, &amp;wc);</span><br></pre></td></tr></table></figure><p><code>count == 0</code> 表示这次没有取到结果，之后可以继续轮询。返回正数才有相应数量的 WC 可读，负数表示轮询调用出错。取到 WC 后，还要检查 <code>wc.status</code>，只有 <code>IBV_WC_SUCCESS</code> 才是请求成功，不能把 <code>count &gt; 0</code> 当成 Write 成功。失败时也不能照常读取所有 WC 字段，<a href="https://github.com/linux-rdma/rdma-core/blob/v59.0/libibverbs/man/ibv_poll_cq.3" target="_blank" rel="noopener">手册</a>明确保证有效的只有 <code>wr_id</code>、<code>status</code>、<code>qp_num</code> 和 <code>vendor_err</code>。</p><p>应用用 <code>wc.wr_id</code> 找回请求并更新状态。对于本例，取得成功完成后，A 就可以复用 <code>a_buffer</code>。这条生命周期规则来自 <a href="https://github.com/linux-rdma/rdma-core/blob/v59.0/libibverbs/man/ibv_post_send.3" target="_blank" rel="noopener"><code>ibv_post_send()</code></a>，而 B 的业务是否已经读过数据、是否处理成功，是另一层状态。</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br></pre></td><td class="code"><pre><span class="line">A 应用构造 WR</span><br><span class="line">    ↓ ibv_post_send()</span><br><span class="line">A 用户态驱动构造 WQE，发布到 SQ，通知网卡</span><br><span class="line">    ↓</span><br><span class="line">A、B 的网卡执行 RC Write 与协议确认</span><br><span class="line">    ↓</span><br><span class="line">A 的 CQ 中出现 CQE</span><br><span class="line">    ↓ ibv_poll_cq()</span><br><span class="line">A 应用取得 WC，检查状态，更新请求并复用源缓冲</span><br></pre></td></tr></table></figure><p>RC 的协议确认由设备处理，不需要 B 的业务程序回复 <code>OK</code>，A 才能取得 Write 的完成。普通 Write 也不消耗 B 的 Receive WR，不会为这次写入在 B 端生成对应的 Receive WC。因此，“等待响应”至少要明确等的是设备的协议响应、本地完成，还是远端业务回复。</p><h2 id="DONE、OK-与目标数据的使用"><a href="#DONE、OK-与目标数据的使用" class="headerlink" title="DONE、OK 与目标数据的使用"></a>DONE、OK 与目标数据的使用</h2><p>前面通过 TCP 发送的 <code>DONE</code> 和 <code>OK</code> 仍然有独立作用。A 在成功完成后发 <code>DONE</code>，把写入完成这件事通知 B。B 检查或消费数据后再返回 <code>OK</code>，A 才知道 B 执行到了应用协议约定的阶段。发送缓冲可复用与远端业务结束，不是同一个回收条件。</p><p>这里要把目标内存的条件交代完整。普通主机内存例子限定在设备与 CPU 之间支持 DMA 一致性的映射上，也就是设备写入能通过平台的一致性机制被 CPU 观察到。B 在得知传输完成后才读取目标区域，不能与仍在进行的写入并发访问。如果收取 <code>DONE</code> 的线程还要通知另一业务线程读数据，这次线程间交接仍需应用自己的同步协议。TCP 在这里承担通知，不能凭一条消息推出任意内存与设备组合的可见性保证。<a href="https://docs.kernel.org/core-api/dma-api-howto.html" target="_blank" rel="noopener">Linux DMA 文档</a>区分了缓存一致性与访问顺序保证。</p><p>链路中列出的 <code>__sync_synchronize()</code>是 GCC 的全内存屏障，它约束 CPU 访存顺序，不负责等待某个 RDMA 请求完成，也不能代替非一致性 DMA 所需的缓存维护，更不能代替 GPU 的可见性同步。它本身没有表达“哪个远端请求已经完成”的信息。<a href="https://gcc.gnu.org/onlinedocs/gcc/_005f_005fsync-Builtins.html" target="_blank" rel="noopener">GCC 接口定义</a>所提供的保证仅是屏障。后面把目标换成 GPU 时，需要重新建立设备写入与消费者之间的顺序，不能只沿用这个函数。</p><h1 id="内核旁路与设备访问"><a href="#内核旁路与设备访问" class="headerlink" title="内核旁路与设备访问"></a>内核旁路与设备访问</h1><p>上面的 <code>ibv_post_send()</code>和 <code>ibv_poll_cq()</code>仍然由 CPU 执行，但 mlx5 的普通用户态快速路径不需要为每次调用进入内核。这就是这里所说的 <strong>kernel bypass，内核旁路</strong>。</p><p>内核先参与资源准备。创建 QP/CQ、注册 MR、建立访问权限和映射等操作，通过 RDMA 子系统和设备驱动完成。mlx5 使用的内核模块包括 <code>mlx5_ib</code> 和 <code>mlx5_core</code>。资源准备好以后，进程可以在获准的范围内访问队列和设备映射，后续不用把每个 WR 再交给内核。<a href="https://docs.kernel.org/infiniband/user_verbs.html" target="_blank" rel="noopener">Linux 用户态 verbs 文档</a>明确区分了资源管理的慢路径和直接访问映射资源的快速路径。</p><p>用户态也有驱动，mlx5 对应的 provider 是 <code>libmlx5</code>。它运行在应用进程中，负责生成 WQE、维护队列、通知设备，以及读取和解释 CQE。因而，只确认内核建连路径正常，还不能排除用户态驱动路径中的问题。</p><p>这个边界可以从 <a href="https://github.com/linux-rdma/rdma-core/blob/v59.0/libibverbs/verbs.h" target="_blank" rel="noopener">v59.0 的 <code>verbs.h</code></a>直接看到：<code>ibv_post_send()</code>调用设备上下文中的 <code>ops.post_send</code>，<code>ibv_poll_cq()</code>调用 <code>ops.poll_cq</code>。沿 mlx5 实现继续看，分别进入 <code>mlx5_post_send()</code>和 <code>mlx5_poll_cq()</code>或对应 CQE 格式的变体。这一段是应用进程内的函数调用。</p><h2 id="队列发布与-doorbell"><a href="#队列发布与-doorbell" class="headerlink" title="队列发布与 doorbell"></a>队列发布与 doorbell</h2><p><strong>doorbell</strong> 是主机通知设备有新工作的机制。mlx5 提交时既更新内存中的 <strong>doorbell record</strong>，记录队列的提交位置，也写入映射到用户态的设备区域，通知设备检查新工作。内存中的队列记录和向设备发出的通知不是同一处写入。</p><p>这两个动作需要顺序保证。如果设备先收到通知，而描述符内容还没有对设备可见，它就不能正确执行工作。v59.0 的 <a href="https://github.com/linux-rdma/rdma-core/blob/v59.0/providers/mlx5/qp.c#L754" target="_blank" rel="noopener"><code>post_send_db()</code></a>先调用 <code>udma_to_device_barrier()</code>，再更新 doorbell record 和进行 MMIO 写。源码注释明确说明，这个屏障用于保证描述符先写好。这里的 MMIO 虽然由用户态代码发起，仍然是在访问实际设备。</p><p>完成方向也有对应的顺序。mlx5 的 CQE 带有 <strong>ownership bit（所有权位）</strong>，provider 根据这个位和当前队列位置，判断条目是否已经交给软件消费。确认可用后，再通过 <code>udma_from_device_barrier()</code>保证后续读取 CQE 内容的顺序，然后解析结果并更新消费位置。<a href="https://github.com/linux-rdma/rdma-core/blob/v59.0/providers/mlx5/cq.c#L531" target="_blank" rel="noopener"><code>cq.c</code></a>中的这条路径表明，<code>ibv_poll_cq()</code>是在读取和消费完成队列，并不是每次向固件同步发送一条查询命令。</p><p><strong>FW（Firmware，固件）</strong>是运行在设备内部的软件，参与设备控制和内部状态管理。数据传输还由网卡的协议与 DMA 硬件引擎承担，不能把每个 WQE 都理解成设备上的一次软件 RPC。应用、用户态驱动、内核驱动、固件和设备硬件是不同层次，排障时需要说明证据覆盖了哪一层。</p><blockquote><p>TCP 上交换 QPN、地址、密钥和 <code>READY/DONE/OK</code>，是应用之间的控制协议。内核驱动向本机网卡下发创建或修改 QP 的命令，是本机的设备控制路径。两者都可以叫控制面，但它们不是同一条链路。QP 配置成功，也不等于后续每个 WQE 的发布、执行和 CQE 的读取都已经验证成功。</p></blockquote><h1 id="RDMA-与-TCP-的协议栈对比"><a href="#RDMA-与-TCP-的协议栈对比" class="headerlink" title="RDMA 与 TCP 的协议栈对比"></a>RDMA 与 TCP 的协议栈对比</h1><p>比较 RDMA 和 TCP 时，既要比较通信语义，也要比较这些语义由谁实现。TCP 提供可靠字节流，RDMA 提供对注册内存的访问和相应工作完成接口，它们不是同一层的两个协议。下面把范围限定为 <strong>Linux 普通 socket TCP</strong> 与 <strong>mlx5 硬件上的用户态 RC/RoCEv2</strong>。两者都使用普通主机内存，TCP 使用带复制的 <code>send()/recv()</code>路径，RDMA Write 不使用 inline。连接、设备队列和 MR 等资源已经准备好。</p><p>仍然让 A 把 <code>a_buffer</code>中的内容传给 B。TCP 这一边，A 把字节交给内核，由 B 调用 <code>recv()</code>放入 <code>b_buffer</code>。RDMA 这一边，A 提交包含 B 的目标地址与 <code>rkey</code>的 Write，网卡负责把数据放进指定位置。沿着这段数据看下去，用户态、内核和设备的分工就能对应起来。</p><h2 id="用户态接口与内核协议处理"><a href="#用户态接口与内核协议处理" class="headerlink" title="用户态接口与内核协议处理"></a>用户态接口与内核协议处理</h2><p><img src="/asset/rdma/tcp-rdma-stack.svg" alt="Linux socket TCP 与硬件 RDMA 的用户态、内核态和设备分层路径"></p><p>图中的实线表示发送提交路径，虚线表示资源配置与设备管理关系，没有画接收、协议确认和完成返回。特别是设备内部的固件框，不表示每份载荷都必须先交给固件软件转发。</p><p>TCP 发送时，应用调用的 libc 接口主要封装系统调用。进入内核后，socket 层把操作交给 TCP 实现，由它维护连接、序号、重传、流量控制和拥塞控制状态，再经 IP 与网络发送层交给网卡驱动。一个 <code>send()</code>可以只接受部分数据，正返回值说明本次接受了多少字节，并不保证对端已经收到，更不保证对端应用已经处理。<a href="https://man7.org/linux/man-pages/man2/send.2.html" target="_blank" rel="noopener">send 手册</a>与 <a href="https://man7.org/linux/man-pages/man7/tcp.7.html" target="_blank" rel="noopener">Linux TCP 说明</a></p><p>在这里选定的普通复制路径中，内核把已接受的载荷复制到自己持有的内存。因此，<code>send()</code>返回后，A 可以复用<strong>返回字节数所覆盖的源缓冲范围</strong>，后续发送和必要的重传不再依赖这份用户内存。Linux v6.12 的 <a href="https://github.com/torvalds/linux/blob/v6.12/net/ipv4/tcp.c" target="_blank" rel="noopener"><code>tcp_sendmsg_locked()</code></a>中可以看到复制分支。TCP 发送返回和 RDMA Write 完成都能与 buffer 生命周期相关，但它们并不是同一个执行阶段。</p><p>RDMA 发送则通过 <code>libibverbs</code>进入 <code>libmlx5</code>。provider 把 WR 转成 WQE，写队列和 doorbell，网卡接手后执行 RC 传输。本次提交没有经过 Linux 的 socket、TCP 或 UDP 数据收发路径。<code>ibv_post_send()</code>返回时，网卡仍然可以尚未读完源缓冲，所以要按前文的完成规则等待，才能复用数据。</p><p>RoCEv2 在线路上有 UDP/IP 头，不表示应用调用了 UDP socket，也不表示每个 RoCE 包都经过 Linux UDP 协议栈。这里的封装和 RC 传输由网卡处理，RC 的确认与重试也不是由 UDP 提供的。内核仍参与网口、地址和路径等配置，<a href="https://docs.nvidia.com/networking/display/mlnxenv24101140lts/rdma+over+converged+ethernet+(roce)" target="_blank" rel="noopener">NVIDIA RoCE 文档</a>明确区分了这些配置依赖与硬件数据路径。</p><p>这使内核承担的工作发生了变化。普通 TCP 中，它既准备资源，也持续处理连接的数据传输。硬件 RDMA 的内核路径主要建立受保护的访问条件，包括设备资源、MR、QP/CQ 和用户态映射，普通提交与轮询随后可以直接使用这些资源。阻塞等待完成通知、处理异步错误和销毁资源时，内核仍会参与，不能把快速路径的旁路推广成整个连接生命周期都不经过内核。</p><h2 id="驱动、固件与硬件的分工"><a href="#驱动、固件与硬件的分工" class="headerlink" title="驱动、固件与硬件的分工"></a>驱动、固件与硬件的分工</h2><p>“内核、驱动、固件”不是三个互斥的位置。内核驱动运行在主机内核态，用户态驱动运行在应用进程里，固件运行在网卡内部。TCP 和 RDMA 的关键区别之一，是哪些设备队列由内核驱动操作，哪些可以交给用户态 provider 操作。</p><p>以同一套 mlx5 硬件为例，Linux 以太网路径中的 <strong>mlx5e</strong> 是 <code>mlx5_core</code>里的以太网驱动部分。它接收内核协议栈交来的 **<code>sk_buff</code>**，也就是保存包元数据、并关联载荷内存的内核对象。驱动建立 DMA 映射，准备发送描述符，再通过 doorbell 通知设备。发送结束后，它处理设备的完成记录，回收相应的映射和队列资源。<a href="https://github.com/torvalds/linux/blob/v6.12/drivers/net/ethernet/mellanox/mlx5/core/en_tx.c" target="_blank" rel="noopener">v6.12 的 <code>en_tx.c</code></a>里同样能找到 WQE、CQE 和 <code>mlx5e_poll_tx_cq()</code>。</p><p>因此，WQE、CQE、doorbell 和 DMA 并不是只有 RDMA 才有。普通 TCP 应用没有直接看到这些设备队列，是因为它们由内核网络驱动管理。硬件 RDMA 则把获准的队列访问能力交给用户态 provider，并通过 verbs 暴露以工作请求为单位的完成语义。TCP 网卡发送队列的一条完成，不等于 TCP 对端已经确认对应字节，更不等于对端应用处理完成。</p><p>两条路径也都会使用网卡固件。内核驱动通过设备命令接口创建、配置和管理资源，<a href="https://github.com/torvalds/linux/blob/v6.12/drivers/net/ethernet/mellanox/mlx5/core/cmd.c" target="_blank" rel="noopener">mlx5 的 <code>cmd.c</code></a>明确把这类操作区分为驱动提交命令和 FW 执行命令。固件配合硬件实现设备功能，但公开的主机侧调用路径不足以确定某个型号、某个固件版本内部每项工作由微码还是固定逻辑完成。因此这里把包处理归到设备侧，不把每个 WQE 画成一次固件软件 RPC，也不把固件描述成只在开机时运行。</p><table><thead><tr><th>执行位置</th><th>Linux 普通 socket TCP</th><th>mlx5 用户态 RC/RoCEv2</th></tr></thead><tbody><tr><td>用户态应用与库</td><td>调用 socket 接口，处理字节流与业务协议</td><td>提交 WR，消费 WC，管理注册 buffer 与业务协议</td></tr><tr><td>用户态设备驱动</td><td>普通 libc socket 路径不直接操作网卡队列</td><td><code>libmlx5</code>生成 WQE、发布 doorbell、消费 CQE</td></tr><tr><td>内核协议与资源层</td><td>管理 socket，并持续执行 TCP/IP 协议处理</td><td>RDMA 子系统管理资源、授权和映射，普通数据快路径旁路</td></tr><tr><td>内核设备驱动</td><td>逐批处理发送、接收和设备完成</td><td>创建、配置、销毁设备资源，并处理相应事件</td></tr><tr><td>网卡固件</td><td>参与设备控制与内部管理</td><td>参与设备控制与内部管理</td></tr><tr><td>网卡硬件</td><td>DMA、包收发及已启用的协议卸载</td><td>DMA、RC 协议处理、MR 访问检查和数据放置</td></tr></tbody></table><p>TCP 一侧已经存在硬件卸载。例如 <strong>TSO（TCP Segmentation Offload，TCP 分段卸载）</strong>让网卡按内核给定的信息，把较大的待发送数据分成线路上的 TCP 段，校验和计算也可以交给网卡。这减少了主机工作，但不代表连接状态、重传和拥塞控制已经整体转移到设备。<a href="https://docs.kernel.org/networking/segmentation-offloads.html" target="_blank" rel="noopener">Linux 分段卸载文档</a>描述了内核给驱动和硬件提供的分段信息。</p><h2 id="接收路径与数据放置"><a href="#接收路径与数据放置" class="headerlink" title="接收路径与数据放置"></a>接收路径与数据放置</h2><p><img src="/asset/rdma/tcp-rdma-buffers.svg" alt="普通复制型 TCP 与非 inline RDMA Write 的载荷缓冲路径"></p><p>图中只画载荷经过的主要 buffer，不把 <code>sk_buff</code>元数据、设备内部暂存、协议头和完成记录算作另一份应用载荷。两条路径都通过 DMA 在网卡与主机内存之间搬数据，差别在于 DMA 指向哪段内存，以及 CPU 是否还要复制载荷。</p><p>TCP 的 B 端网卡先把包写到内核驱动准备的接收内存。驱动处理接收完成，把包交给内核网络栈。这里常用 <strong>NAPI</strong>，即 Linux 网络子系统组织驱动接收处理和发送回收的轮询机制。它可以由中断触发调度，也支持主动轮询，因此不能把普通 TCP 描述成“每来一个包，应用线程就被中断一次”。NAPI 运行在内核的处理上下文中，与用户线程调用 <code>ibv_poll_cq()</code>是不同层的轮询。<a href="https://docs.kernel.org/networking/napi.html" target="_blank" rel="noopener">NAPI 文档</a>、<a href="https://github.com/torvalds/linux/blob/v6.12/drivers/net/ethernet/mellanox/mlx5/core/en_rx.c" target="_blank" rel="noopener">mlx5 接收实现</a></p><p>内核 TCP 负责检查连接和序号、处理乱序、推进可读字节流。B 调用 <code>recv()</code>时，内核再把相应字节复制到该调用提供的用户缓冲。Linux v6.12 的 <a href="https://github.com/torvalds/linux/blob/v6.12/net/ipv4/tcp.c" target="_blank" rel="noopener"><code>tcp_recvmsg_locked()</code></a>中，普通接收分支调用 <code>skb_copy_datagram_msg()</code>完成这次复制。A 的一次 <code>send()</code>与 B 的一次 <code>recv()</code>没有消息边界上的一一对应关系，业务仍需自行判断这段数据何时收齐。</p><p>普通 RDMA Write 的 B 端则由网卡找到目标 QP，检查远端访问权限、<code>rkey</code>与地址范围，再把数据放入 B 已注册的目标区域。每次写入不需要经过 B 的内核 TCP/IP 栈，也不需要 B 调用 <code>recv()</code>把载荷搬进最终 buffer。B 仍要事先提供目标空间，事后按通知和可见性协议开始消费，不能因为省掉了接收复制就省掉数据生命周期管理。</p><p>至此能分清几种“完成”：TCP 的 <code>send()</code>返回表达内核接受数据，设备 TX 完成用于驱动回收发送资源，TCP ACK 表达对端传输层确认，<code>recv()</code>返回表达这次调用取出了字节。RDMA 的提交返回与 WC 则分别表达工作已提交和工作执行结果。两边都要通过额外的业务状态，才能知道 B 已经处理完这段数据。前面使用的 <code>DONE/OK</code>就是这种应用层交接。</p><h2 id="其他实现路径补充"><a href="#其他实现路径补充" class="headerlink" title="其他实现路径补充"></a>其他实现路径补充</h2><p><strong>减少复制、内核旁路和协议卸载是不同的优化维度。</strong>例如 Linux 的 <code>MSG_ZEROCOPY</code>可以让 TCP 发送引用用户页面，减少用户态到内核的载荷复制，但仍使用内核 TCP 协议栈。应用还要等待 socket 错误队列中的回收通知才能复用页面，不能继续套用普通复制型 <code>send()</code>的生命周期规则。它也不保证每次都消除复制，内核文档明确允许退回复制路径，通知表达的是用户页面可以复用，而不是远端业务完成。<a href="https://docs.kernel.org/networking/msg_zerocopy.html" target="_blank" rel="noopener">MSG_ZEROCOPY 文档</a></p><p>RDMA 也不必然意味着设备执行了全部传输逻辑。Linux 的 RXE 是软件 RoCE 实现，其协议处理路径有内核软件参与，不能套用上图 mlx5 的硬件分工。另一方面，<strong>iWARP</strong>是一组能在 TCP 之上提供 RDMA 的协议，说明 RDMA 与 TCP 也不是天然互斥的选项。<a href="https://www.rfc-editor.org/rfc/rfc5040.html" target="_blank" rel="noopener">RFC 5040</a>给出了 RDMA 协议位于 TCP 之上的分层关系。讨论某个系统的 CPU 开销或时延时，需要明确实际 API、软件实现和硬件能力，不能只凭“TCP”或“RDMA”这个名称推断。</p><h1 id="完成队列的共享与进展"><a href="#完成队列的共享与进展" class="headerlink" title="完成队列的共享与进展"></a>完成队列的共享与进展</h1><h2 id="完成分发"><a href="#完成分发" class="headerlink" title="完成分发"></a>完成分发</h2><p>单个请求只要找到自己的完成，多个 QP 共用 CQ 时，结果就会混在一起。应用正在等待请求 X，不代表下一次 poll 出来的 WC 就属于 X。完成处理代码要利用应用分配的 <code>wr_id</code>，必要时结合 <code>qp_num</code>，把每条结果交给对应请求的状态机。</p><p>这里有个决定实现方式的性质：<strong>poll 是消费，不是窥视</strong>。<a href="https://github.com/linux-rdma/rdma-core/blob/v59.0/libibverbs/man/ibv_poll_cq.3" target="_blank" rel="noopener"><code>ibv_poll_cq()</code></a>规定，每个取出的完成都会从 CQ 移除，不能再放回去。为了等待 X 而丢掉其他 WC，会让那些请求失去完成通知。CQ 空间是在消费完成记录时释放的，不会等应用的业务回调执行完才释放。</p><p>因此，请求的状态更新和等待逻辑需要分开。完成线程负责分发所有已经到达的结果，等待 X 的业务线程观察 X 的状态。<code>wr_id</code> 所指向的请求状态也必须活到完成处理结束，不能在请求提交后就回收或复用。</p><h2 id="完成线程停顿与-CQ-溢出"><a href="#完成线程停顿与-CQ-溢出" class="headerlink" title="完成线程停顿与 CQ 溢出"></a>完成线程停顿与 CQ 溢出</h2><p>把例子扩展为两个独立 QP：<code>QP_X</code> 的完成进入 <code>CQ_X</code>，<code>QP_Y</code> 的完成进入 <code>CQ_Y</code>，由同一个线程 T 轮流消费。只选两个 QP，是为了说明一条等待路径如何阻断另一条完成路径，不是在规定连接规模。</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line">QP_X → CQ_X ─┐</span><br><span class="line">              ├→ 完成线程 T → 各请求的状态</span><br><span class="line">QP_Y → CQ_Y ─┘</span><br></pre></td></tr></table></figure><p>假设 T 处理请求 X 时，进入一个只轮询 <code>CQ_X</code> 的循环，直到 X 完成才退出。X 暂时没有结果，T 就不会再消费 <code>CQ_Y</code>。但 <code>QP_Y</code> 已提交的工作仍在执行，并把结果写进 <code>CQ_Y</code>。</p><p>再假设这批工作会报告的完成数量超过 <code>CQ_Y</code> 的剩余容量，而且能在 T 恢复消费之前完成。当未消费的记录占满队列，设备还要写入下一条记录时，就发生 <strong>CQ overrun，完成队列溢出</strong>。这里特意选取了容量装不下这批结果的配置，不是容量建议，也不依赖停止消费后还能无限提交新工作。</p><p>这个时序中，溢出依赖消费停顿和足够多的完成记录同时成立。只有 X 一直没有完成，而没有别的完成写入队列，并不会把 CQ 填满。所谓“其他事件”也必须具体到进入这个 CQ 的工作完成，例如其他 QP 的发送完成或接收完成。没有必要假设同一个 RC QP 的后续操作可以任意越过前面的操作。</p><p>如果 X 与其他请求共用一个 CQ，且 T 等待 X 时继续正常 poll、分发其他 WC，X 缺少完成这件事本身就不会堵住 CQ。甚至可以只有 X 一个未完成请求，而 CQ 始终为空。此时占住的是请求及相关资源，和完成记录过多是不同的问题。</p><p>由这个例子可以直接得到完成线程的约束：负责推进多个 CQ 的线程，不应在单个请求上进入无法退出的局部等待。它可以更新请求状态，再唤醒业务线程，耗时业务回调也不宜直接阻塞完成循环。</p><p>CQ 容量能吸收突发，不能解决长期无人消费。容量要结合所有关联 QP 的完成数量和允许的消费停顿考虑，也要考虑错误完成。创建 CQ 时请求的是最低容量，实际容量应读取返回对象的 <code>cqe</code> 字段。<a href="https://github.com/linux-rdma/rdma-core/blob/v59.0/libibverbs/man/ibv_create_cq.3" target="_blank" rel="noopener"><code>ibv_create_cq()</code></a>与 <a href="https://github.com/linux-rdma/rdma-core/blob/v59.0/libibverbs/man/ibv_poll_cq.3" target="_blank" rel="noopener"><code>ibv_poll_cq()</code></a>分别规定了容量和溢出语义。在普通 verbs 配置下，overrun 会触发 <code>IBV_EVENT_CQ_ERR</code>，该 CQ 不再可用，需要进入受影响资源的恢复流程，不能继续把它当成普通积压处理。</p><h2 id="工作完成与-CQ-通知"><a href="#工作完成与-CQ-通知" class="headerlink" title="工作完成与 CQ 通知"></a>工作完成与 CQ 通知</h2><p>前面都是忙轮询。如果希望没有工作时阻塞等待，可以创建 <strong>completion channel（完成通知通道）</strong>，把 CQ 关联到它，通过 <code>ibv_req_notify_cq()</code>请求通知，再用 <code>ibv_get_cq_event()</code>等待哪个 CQ 需要处理。通知用于唤醒应用，实际结果仍保存在 CQ 中，醒来后还要 <code>ibv_poll_cq()</code>。</p><p>这几种对象不宜都笼统叫作“完成事件”：</p><table><thead><tr><th>对象</th><th>获取方式</th><th>表达的状态</th></tr></thead><tbody><tr><td>工作完成 WC</td><td><code>ibv_poll_cq()</code></td><td>哪个请求完成，以及成功或失败状态</td></tr><tr><td>CQ 通知</td><td><code>ibv_get_cq_event()</code></td><td>哪个 CQ 发出了通知，需要检查</td></tr><tr><td>异步状态或错误事件</td><td><code>ibv_get_async_event()</code></td><td>QP、CQ 或设备等资源的状态变化，例如 <code>IBV_EVENT_CQ_ERR</code></td></tr></tbody></table><p><code>ibv_req_notify_cq(cq, 0)</code>中的 <code>0</code> 表示不把通知限定为带 solicited 条件的完成。通知请求是一次性的，下一次通知需要重新请求，和 <code>IBV_SEND_SIGNALED</code>决定是否生成正常发送完成是两套机制。<a href="https://github.com/linux-rdma/rdma-core/blob/v59.0/libibverbs/man/ibv_req_notify_cq.3.md" target="_blank" rel="noopener">通知接口定义</a></p><p><a href="https://github.com/linux-rdma/rdma-core/blob/v59.0/libibverbs/man/ibv_get_cq_event.3" target="_blank" rel="noopener"><code>ibv_get_cq_event()</code>的示例</a>给出的处理顺序是：在工作开始前请求通知，取得通知后确认事件、重新请求通知，然后把 CQ 排空，再进入下一轮等待。<strong>重新请求通知要在排空之前</strong>。如果先排空再请求，两者之间新到达的 CQE 就落在没有通知请求的窗口中，之后仅阻塞等通知会漏掉这次进展。</p><p>反过来，在重新请求通知之后、排空之前到达的 CQE，既能触发通知，又会被本轮 poll 取走。因此下一次取得通知时，即使 CQ 已经为空，也是合法时序。通知不是每条 CQE 的一一对应副本。如果是在已经有工作的 CQ 上切换到通知模式，也要在请求通知后先检查并排空已有结果，再决定是否阻塞。</p><p>从通道取出的通知必须用 <code>ibv_ack_cq_events()</code>确认，这个 ack 只确认通知事件，不消费工作完成，也不替代重新请求通知。<a href="https://github.com/linux-rdma/rdma-core/blob/v59.0/libibverbs/man/ibv_get_async_event.3" target="_blank" rel="noopener">异步资源事件</a>则走另一条接口路径，不能用空 CQ 来判断是否存在设备或 QP 错误。阻塞等待通知涉及操作系统的等待与唤醒，前文不进入内核的说法限定在普通提交和轮询的快速路径。</p><h2 id="完成状态与故障归因"><a href="#完成状态与故障归因" class="headerlink" title="完成状态与故障归因"></a>完成状态与故障归因</h2><p>请求重试耗尽可以正常生成一条失败 WC，这是“执行失败，但结果被送达”。CQ overrun 是传递结果的队列出了问题。长期没有拿到预期 WC，则只是“应用尚未获得结果”，还不能直接归入前面任何一种，更不能直接归因于固件。</p><p>仍然沿同一次 Write 检查，就能把证据串起来。先确认 <code>ibv_post_send()</code>返回什么、WR 是否要求报告完成，再确认 WQE 是否发布给设备、队列是否推进，以及 CQE 是否被某个完成线程取走却没有正确分发。失败 WC 的状态与 <code>vendor_err</code>、异步资源事件、设备侧诊断，则用来进一步区分权限、传输和设备状态问题。</p><p>内核创建和修改 QP 成功，只覆盖了资源配置路径。源码中 WQE 构造、doorbell 发布和 CQE 消费都有用户态 provider 参与，因此“数据路径绕过内核”不能作为“已经排除驱动”的证据。要把问题缩小到 FW，需要设备侧证据，或能区分上述环节的对照验证。一次空轮询只说明这次没有取到完成。</p><h1 id="SEND-RECV-与远端通知"><a href="#SEND-RECV-与远端通知" class="headerlink" title="SEND/RECV 与远端通知"></a>SEND/RECV 与远端通知</h1><p>普通 Write 由 A 指定 B 的目标地址。<strong>SEND/RECV</strong>则是匹配发送请求与接收请求的双边消息语义：B 先调用 <code>ibv_post_recv()</code>，用 Receive WR 描述可用接收缓冲，A 再用 SEND 发消息，B 的网卡把消息放进匹配的接收缓冲，并报告接收完成。A 不需要知道 B 的具体 buffer 地址，目标位置由 B 的接收请求决定。<a href="https://networking-docs.nvidia.com/doca/archive/3-5-0/rdma-aware-networks-programming-guide" target="_blank" rel="noopener">操作说明</a></p><p>“双边”并不表示 B 的 CPU 要参与每个字节的复制。B 可以通过 <code>ibv_post_recv()</code>的链表参数预先提交一批 Receive WR，由后续消息逐条消耗，但完成后需要按协议补充接收资源。在 RC 上，SEND 到达时没有可匹配的 Receive WR，会触发 RNR 响应，发送端按 RNR 重试配置处理，耗尽时报告失败。</p><p><strong>Write with Immediate</strong>仍按 A 提供的远端地址和 <code>rkey</code>写数据，同时携带一份 <strong>immediate data（即时数据）</strong>，把它作为通知交给 B 的接收完成。它消耗 B 预先提交的 Receive WR，并产生 <code>IBV_WC_RECV_RDMA_WITH_IMM</code>。接收请求在这里提供的是通知所需的接收资源，数据正文仍写入远端地址指定的位置，不写进 Receive WR 的 SGE 所指定的缓冲。<a href="https://networking-docs.nvidia.com/doca/archive/3-5-0/rdma-aware-networks-programming-guide" target="_blank" rel="noopener">操作语义</a>、<a href="https://github.com/linux-rdma/rdma-core/blob/v59.0/libibverbs/man/ibv_wr_post.3.md" target="_blank" rel="noopener">扩展 WR 接口</a></p><table><thead><tr><th>操作</th><th>B 端数据地址由谁决定</th><th>是否消耗 B 的 Receive WR</th><th>B 是否得到对应的接收完成</th></tr></thead><tbody><tr><td>普通 RDMA Write</td><td>A 提供的远端地址与 <code>rkey</code></td><td>否</td><td>否</td></tr><tr><td>SEND</td><td>B 预先提交的接收请求</td><td>是</td><td>是</td></tr><tr><td>Write with Immediate</td><td>A 提供的远端地址与 <code>rkey</code></td><td>是，用于通知</td><td>是，带即时数据</td></tr></tbody></table><p>这也限定了前面讨论 KVCache 传输时的适用条件。普通 Write 避免的是每次写入对 Receive WR 的依赖，所以不会因缺少 Receive WR 而遇到 RNR，但 B 仍要负责目标缓存块的分配、授权、生命周期和就绪通知。改用 Write with Immediate 后，接收资源的供给又成为必要条件，缺少 Receive WR 同样会触发 RNR。</p><p>Write 能直接落入最终缓存地址，前提是这段内存可注册、可访问，并且 A 已获得目标位置。SEND 也能把最终目标 buffer 预先作为接收缓冲，并不必然多一次中转。对 KVCache，真正的选择在于由谁决定块的位置、怎样管理接收资源，以及用什么协议交接数据。前面的 <code>TransferEntry</code>只是应用组织传输条目的例子，不是 verbs 对象，批量提交也不是 Write 独有的能力。</p><h1 id="接口与完成语义补充"><a href="#接口与完成语义补充" class="headerlink" title="接口与完成语义补充"></a>接口与完成语义补充</h1><h2 id="发送完成策略与缓冲区生命周期"><a href="#发送完成策略与缓冲区生命周期" class="headerlink" title="发送完成策略与缓冲区生命周期"></a>发送完成策略与缓冲区生命周期</h2><p><code>sq_sig_all</code>非零时，所有发送侧 WR 都要求生成完成记录。它为零时，由各 WR 的 <code>IBV_SEND_SIGNALED</code>选择要报告的正常完成。没有设置 signaling 的请求称为 <strong>unsignaled WR</strong>，成功执行后不生成独立的成功完成记录，因此不能逐个等待它们的成功 WC。</p><p>Unsignaled 并不意味着请求不占发送资源，也不允许立即复用源数据。选择性 signaling 的实现还必须跟踪队列进度和可回收的请求范围，不能只减少 CQE 数量，却取消资源回收协议。本篇单次 Write 显式请求完成，就是为了让这个生命周期直接可见。</p><p>错误又是另一种情况。Unsignaled 抑制正常成功完成，不屏蔽失败完成。QP 进入错误状态后，未完成工作还会以 flush 错误结束，<strong>flush 在这里表示清理尚未完成的工作，不表示成功传输</strong>。<a href="https://github.com/torvalds/linux/blob/v6.12/drivers/infiniband/sw/rxe/rxe_comp.c#L432" target="_blank" rel="noopener">Linux v6.12 的 RXE 完成实现</a>直接引用了 InfiniBand 规范的这一要求，并分别处理正常、错误和 flush 完成。RXE 是 Linux 的软件 RoCE 实现，这里用它核对规范语义，不用它代替 mlx5 的硬件实现。CQ 本身已经出错时，结果交付不再有健康 CQ 的保证，不能继续用正常完成规则推理。</p><blockquote><p>如果设置 <code>IBV_SEND_INLINE</code>，provider 会在提交过程中把源数据复制进 WQE。按照 <a href="https://github.com/linux-rdma/rdma-core/blob/v59.0/libibverbs/man/ibv_post_send.3" target="_blank" rel="noopener"><code>ibv_post_send()</code></a>的约定，调用返回后即可复用原始源缓冲，之后网卡使用的是 WQE 内的数据。这种方式受 QP 的 inline 容量限制，前面的例子没有使用它。源 buffer 可以复用，也不表示远端业务已经完成。</p></blockquote><h2 id="批量提交与扩展接口"><a href="#批量提交与扩展接口" class="headerlink" title="批量提交与扩展接口"></a>批量提交与扩展接口</h2><p><code>ibv_post_send()</code>可以提交由 <code>next</code>连接的 WR 链表。如果中途遇到能立即检测的错误，<code>bad_wr</code>指向失败项，之前的 WR 已经提交，失败项和后续项没有继续提交。因此处理返回错误时，要区分整批失败和前缀已经提交，不能盲目重试整条链表。<a href="https://github.com/linux-rdma/rdma-core/blob/v59.0/libibverbs/man/ibv_post_send.3" target="_blank" rel="noopener">提交接口</a></p><p>扩展的 <code>ibv_wr_*</code>接口用 <code>ibv_wr_start()</code>开始构造，通过若干 builder/setter 调用描述工作，最后用 <code>ibv_wr_complete()</code>提交。这里的 complete 是结束构造与提交，不是等待设备执行结束。它与传统链表接口的失败边界也不同：构造期间检测到错误后，<code>ibv_wr_complete()</code>会报告失败并放弃这一批提交。两套接口都需要通过完成机制管理成功提交的异步工作。<a href="https://github.com/linux-rdma/rdma-core/blob/v59.0/libibverbs/man/ibv_wr_post.3.md" target="_blank" rel="noopener">扩展接口手册</a></p><h1 id="GPUDirect-RDMA-同步补充"><a href="#GPUDirect-RDMA-同步补充" class="headerlink" title="GPUDirect RDMA 同步补充"></a>GPUDirect RDMA 同步补充</h1><p><strong>GPUDirect RDMA</strong>允许支持的第三方设备直接访问 GPU 内存，让网卡传输不必先在普通主机内存中转。它增加了一条外部设备访问显存的路径，因此需要分别确认网卡完成、数据对 GPU 可见，以及消费数据的 GPU kernel 已经结束。后一个状态决定显存块什么时候能被覆盖或释放。<a href="https://docs.nvidia.com/cuda/gpudirect-rdma/index.html#synchronization-and-memory-ordering" target="_blank" rel="noopener">NVIDIA GPUDirect RDMA 文档</a></p><h2 id="CUDA-生成数据后交给网卡"><a href="#CUDA-生成数据后交给网卡" class="headerlink" title="CUDA 生成数据后交给网卡"></a>CUDA 生成数据后交给网卡</h2><p>假设 A 先用 CUDA 在显存中生成源数据，再让网卡读取。<code>cuPointerSetAttribute()</code>的 <code>CU_POINTER_ATTRIBUTE_SYNC_MEMOPS</code>属性以一次显存分配为作用范围。把它设为布尔值 <code>1</code>，要求涉及这块分配的 CUDA <strong>同步内存操作</strong>真正同步完成，不再采用使这类 API 提前返回的优化。<a href="https://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__UNIFIED.html" target="_blank" rel="noopener">属性定义</a></p><p>NVIDIA 给出的例子是 <code>cuMemcpyDtoD()</code>后紧接一次外部设备读取。没有相应同步约束时，这类设备到设备复制允许在排入 GPU 调度后就向 CPU 返回，随后安排的网卡读取就会与尚未完成的复制冲突。启用该属性后，CUDA 复制的返回才提供这里所需的同步边界。属性按分配设置，通常不应在每次传输时重复配置。<a href="https://docs.nvidia.com/cuda/gpudirect-rdma/index.html#synchronization-and-memory-ordering" target="_blank" rel="noopener">同步规则与示例</a></p><p>这个属性没有把所有 CUDA 工作改成同步执行。若数据由异步复制或 kernel 生成，仍需等待相应 stream 或 event 所表达的生产完成，再把源数据交给网卡。它也不负责把未来的外部 RDMA 写入自动发布给 GPU 消费者。</p><h2 id="网卡写入后交给-GPU"><a href="#网卡写入后交给-GPU" class="headerlink" title="网卡写入后交给 GPU"></a>网卡写入后交给 GPU</h2><p>方向换成网卡写 B 的显存后，关注点就变成 GPU 何时能观察到写入。<a href="https://docs.nvidia.com/cuda/gpudirect-rdma/index.html#synchronization-and-memory-ordering" target="_blank" rel="noopener">GPUDirect 文档</a>明确指出，与 RDMA 写入并发运行、又读取被覆盖内存的 kernel 会形成数据竞争，能够看到旧数据、部分数据或乱序到达的数据。CPU 上的通用内存屏障不能修复这种竞争。</p><p><code>cuFlushGPUDirectRDMAWrites(target, scope)</code>用于等待针对目标 CUDA context 的外部写入对指定的 GPU 观察范围可见。这里的 CUDA context 是 CUDA 管理设备执行状态和资源的上下文，和 <code>ibv_context</code>是不同对象。<code>target</code>目前使用 <code>CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TARGET_CURRENT_CTX</code>指定当前 CUDA context，<code>scope</code>指定要求哪个范围能一致地消费这些写入，例如拥有这段数据的设备 context，或所有 CUDA 设备 context。它不负责等待未来还没有发出的 RDMA 请求，也不表示 GPU 已经处理完数据。<a href="https://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__DEVICE.html" target="_blank" rel="noopener">CUDA Driver API</a>、<a href="https://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__TYPES.html" target="_blank" rel="noopener">参数枚举</a></p><p>这里的“按需 flush”有明确判断条件。用 <code>cuDeviceGetAttribute()</code>查询 <code>CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_WRITES_ORDERING</code>，得到平台原生保证的可见范围。如果所需 scope 已经被它覆盖，文档规定 flush 是空操作，可以省略。如果需要显式的主机侧 flush，还要查询 <code>CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_FLUSH_WRITES_OPTIONS</code>是否含有 <code>CU_FLUSH_GPU_DIRECT_RDMA_WRITES_OPTION_HOST</code>，确认设备支持这个 API。<a href="https://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__TYPES.html" target="_blank" rel="noopener">能力枚举</a>不能用“所有 GPU 都需要 flush”或“所有 GPU 都自动可见”代替。</p><p>因此，一条由 CPU 协调的消费路径是：先通过通信完成协议确认本轮 RDMA 写入结束，再在需要且支持时建立所需 scope 的可见性，随后由 CPU 提交依赖这些数据的 CUDA 工作。GPU 工作结束后，才能按应用协议允许下一轮覆盖目标块。<code>SYNC_MEMOPS</code>与 flush 约束的是这条路径中的不同方向，不能互相替代。</p><blockquote><p>CUDA 文档还单独指出：在支持多条硬件访问路径的平台上，不同路径可以属于不同的排序域。混合使用这些路径时，即便查询结果显示原生支持所需范围，也需要按具体路径建立额外顺序，不能把本节的单一路径推理直接推广过去。本文没有具体硬件配置，不据此判断某台机器是否需要显式 flush。</p></blockquote><h1 id="InfiniBand-流量分类补充"><a href="#InfiniBand-流量分类补充" class="headerlink" title="InfiniBand 流量分类补充"></a>InfiniBand 流量分类补充</h1><p><strong>SL（Service Level，服务级别）</strong>是包携带的流量分类标记，<strong>VL（Virtual Lane，虚拟通道）</strong>是物理链路上用于区分排队与流控状态的逻辑通道。SL 表达流量属于哪一类，VL 决定它在这一跳走哪个逻辑通道，这两个编号不是同一个对象。</p><p>交换设备根据入端口、出端口和 SL，通过 SL-to-VL 映射表选取输出 VL，再按配置的优先级和权重在不同 VL 间仲裁。<a href="https://docs.nvidia.com/networking/display/mlnxofedv24101140lts/qos+-+quality+of+service" target="_blank" rel="noopener">NVIDIA 的 IB QoS 文档</a>描述了映射与仲裁机制。因此，相同 SL 不能脱离路径配置直接理解成全网固定的一条 VL。</p><p>即使映射到了不同 VL，它们仍共享同一条物理链路。可以理解为分了排队通道，但共用出口，增加逻辑通道并没有增加物理带宽。这一段讲的是 IB，RoCE 的以太网优先级与队列映射需要按对应配置判断，不能直接套用 IB 的 VL。</p><h1 id="NUMA-亲和性补充：网卡、内存与-UPI"><a href="#NUMA-亲和性补充：网卡、内存与-UPI" class="headerlink" title="NUMA 亲和性补充：网卡、内存与 UPI"></a>NUMA 亲和性补充：网卡、内存与 UPI</h1><p><a href="https://www.calvinneo.com/2025/01/03/memory-context-knowledge/">内存领域知识</a>讨论过 CPU 访问远端 NUMA 内存的代价。换成 RDMA，发起内存访问的变成了网卡（NIC），但物理距离并没有消失。因此，除了线程在哪运行，还要看 <strong>NIC 接在哪个 Socket，以及 buffer 的物理页在哪个 NUMA 节点</strong>。</p><h2 id="PCIe、UPI-与跨插槽数据路径"><a href="#PCIe、UPI-与跨插槽数据路径" class="headerlink" title="PCIe、UPI 与跨插槽数据路径"></a>PCIe、UPI 与跨插槽数据路径</h2><p>在常见的 Intel 双路服务器中，每颗 CPU 各自连接 DRAM 和 PCIe 设备，两个 Socket 通过 UPI（Ultra Path Interconnect，Intel Xeon 的跨插槽互联）传输数据并维护缓存一致性。下面假设一个 Socket 对应一个 NUMA 节点，0、1 只是示例编号：</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line">DRAM 0 -- Socket 0 ===== UPI ===== Socket 1 -- DRAM 1</span><br><span class="line">             |                       |</span><br><span class="line">            PCIe                    PCIe</span><br><span class="line">             |                       |</span><br><span class="line">            NIC 0                   NIC 1</span><br></pre></td></tr></table></figure><p>如果 NIC 1 发送的数据需要从 DRAM 0 取回，数据路径就是 <code>DRAM 0 → Socket 0 → UPI → Socket 1 → PCIe → NIC 1</code>。这里经过的是处理器内部的内存控制器和 I/O 硬件，不是 CPU 核在执行 <code>memcpy</code>。DMA 省掉了 CPU 复制，却没有省掉跨插槽传输，这部分流量仍会与其他跨插槽访问竞争 UPI 带宽。</p><p>这也说明，PCIe 与 UPI 是这条路径上串联的两段路。要避开 UPI，应让 NIC 1 使用 DRAM 1 中的 buffer，或者改用 NIC 0 发送 DRAM 0 中的数据。先把数据从 DRAM 0 复制到 DRAM 1，只是把跨 UPI 的工作移到了复制阶段。</p><p>线程位置则是另一件事。buffer 与 NIC 都在节点 1 时，即使提交线程在节点 0，数据的 DMA 仍可以是本地的。但这个线程访问节点 1 上的队列内存、网卡映射或数据时，CPU 的访问路径仍然跨节点。RDMA Write 的接收端同样要检查 NIC 与目标 buffer 的位置，不能因为目标 CPU 不参与复制，就认为没有跨插槽流量。</p><p><a href="https://docs.kernel.org/driver-api/pci/p2pdma.html" target="_blank" rel="noopener">PCIe P2P</a> 指设备之间的直接访问，例如 NIC 读写 GPU 显存。拓扑允许时，事务可以在 PCIe 交换芯片内转发，但它并没有给普通 DRAM 增加一个绕过 UPI 的入口。真正改变上述连接方式的是 <a href="https://networking-docs.nvidia.com/connectx8hw/introduction#Socket-Direct-SuperNICs" target="_blank" rel="noopener">Socket Direct</a>：支持它的网卡通过两条独立的 PCIe 连接分别接入两个 Socket，在正确选择和配置接口后，两侧都能获得本地 DMA 路径。双网络端口不等于双主机侧 PCIe 连接。</p><p>此外，跨 NUMA 不一定跨 Socket。Intel SNC（Sub-NUMA Clustering）能把一个 Socket 划成多个 NUMA 节点，同 Socket 内的跨节点访问不需要经过跨插槽 UPI，所以必须结合实际拓扑判断。</p><h2 id="从-RDMA-设备查到物理拓扑"><a href="#从-RDMA-设备查到物理拓扑" class="headerlink" title="从 RDMA 设备查到物理拓扑"></a>从 RDMA 设备查到物理拓扑</h2><p>verbs 选择的是 <code>mlx5_0</code> 这样的 RDMA 设备，而不是 <code>eth0</code> 这样的 Linux 网口。<a href="https://www.calvinneo.com/2026/09/18/rdma-assessment/">RDMA 评估指标</a>里的 <code>mlx5_bond_0</code> 则是某些 RoCE LAG（Link Aggregation，链路聚合）配置中的 RDMA 聚合设备。名称不包含 NUMA 归属，需要先查它对应的网口：</p><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">ibdev2netdev</span><br><span class="line">rdma link show</span><br></pre></td></tr></table></figure><p>输出中的 RDMA 端口号，也就是 <code>ib_write_bw -i</code> 的参数，与 NUMA 节点号无关。如果网口是 Linux 聚合接口 <code>bond0</code>，先用 <code>cat /proc/net/bonding/bond0</code> 找到 <code>Slave Interface</code> 成员，再逐个查询物理网口。下面的设备名均为示例，应替换成机器的实际输出：</p><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line">nic=eth0</span><br><span class="line">cat <span class="string">"/sys/class/net/<span class="variable">$nic</span>/device/numa_node"</span></span><br><span class="line">cat <span class="string">"/sys/class/net/<span class="variable">$nic</span>/device/local_cpulist"</span></span><br><span class="line">readlink -f <span class="string">"/sys/class/net/<span class="variable">$nic</span>/device"</span></span><br><span class="line">lscpu -e=CPU,NODE,SOCKET</span><br></pre></td></tr></table></figure><p><code>numa_node</code> 是内核报告的设备所属节点，<code>local_cpulist</code> 是就近逻辑 CPU 列表，<code>readlink</code> 显示 PCI 设备路径。将节点号与 <code>lscpu</code> 的 <code>NODE</code>、<code>SOCKET</code> 两列对照，就能确定对应的 Socket。若 <code>numa_node</code> 返回 <code>-1</code>，表示归属未知，不是访问各节点的成本相同。</p><p>聚合设备自身的 sysfs 路径不能代替逐成员检查，单个 <code>device</code>链接不提供所有成员的拓扑。成员若分属不同 Socket，还要结合聚合实现确认实际使用的 PCIe 路径。RoCE LAG 与 Socket Direct 是不同机制，不能从一个 bond 名字推断出双 Socket 连接。</p><h2 id="内存分配与-MR-注册"><a href="#内存分配与-MR-注册" class="headerlink" title="内存分配与 MR 注册"></a>内存分配与 MR 注册</h2><p>前面示例中的 <code>posix_memalign</code>只保证对齐。对常规、非按需分页的主机内存注册，<code>ibv_reg_mr()</code>会固定物理页并建立设备映射，但不会按 NIC 的位置自动迁移页面。</p><blockquote><p><strong>ODP（On-Demand Paging，按需分页）</strong>允许支持它的设备与驱动按需建立页面访问，<code>ibv_reg_mr()</code>提供 <code>IBV_ACCESS_ON_DEMAND</code>选项。因此“注册 MR”不能一概定义成“一次性固定所有物理页”。这里讨论的是普通预注册 buffer 的落点。<a href="https://github.com/linux-rdma/rdma-core/blob/v59.0/libibverbs/man/ibv_reg_mr.3" target="_blank" rel="noopener">注册接口</a></p></blockquote><p><a href="https://docs.kernel.org/admin-guide/mm/numa_memory_policy.html" target="_blank" rel="noopener">Linux 默认的本地分配策略</a>下，新匿名页通常在首次写入触发缺页时才分配物理内存，这就是 first-touch。主线程在节点 0 初始化 buffer 后，再把发送线程绑到节点 1，已有页面并不会跟着移动。注册 MR 也可能触发尚未分配页面的缺页，所以应当<strong>先设置线程与内存策略，再分配、初始化 buffer，最后注册 MR</strong>。</p><p>假设查出的 NIC 属于节点 1，可以这样启动程序，两个 <code>1</code> 都来自刚才的节点查询结果，<code>./rdma_demo</code> 替换成实际程序：</p><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">numactl --cpunodebind=1 --membind=1 ./rdma_demo</span><br></pre></td></tr></table></figure><p><code>numactl</code> 不会替程序选网卡，程序仍需选择对应的 RDMA 设备。多网卡程序可以按节点建立 buffer 池，用 <code>mbind</code> 为各池设置内存分配策略，让生产数据的线程直接写入对应 NIC 的本地内存。</p><p>页面落点可以沿用前文的 <code>move_pages</code> 验证：传入 <code>nodes == NULL</code> 查询各页的实际节点。<code>numastat -p</code> 只有进程整体分布，不能证明某个 buffer 已经本地化。</p><p>性能验证时，固定 RDMA 设备、线程亲和性、消息大小和 QP 配置，只切换 buffer 所在节点，再比较吞吐和延迟，必要时结合平台的互联与 I/O 硬件计数器。<code>perf mem</code> 采样的是 CPU 访存，不能据此判断 NIC 的 DMA 有没有跨 Socket。</p><h1 id="参考资料"><a href="#参考资料" class="headerlink" title="参考资料"></a>参考资料</h1><p>接口与 mlx5 用户态源码固定到 rdma-core <strong>v59.0</strong>，TCP、mlx5 内核驱动与 RXE 源码固定到 Linux <strong>v6.12</strong>。原有在线文档核对日期为 <strong>2026-10-15</strong>，TCP/RDMA 分层对比补充核对于 <strong>2026-10-16</strong>。本文示例用于说明语义，不是特定网卡或固件的实测结论。</p><ul><li><a href="https://docs.kernel.org/infiniband/user_verbs.html" target="_blank" rel="noopener">Linux：Userspace verbs access</a>，资源管理与用户态快速路径。</li><li><a href="https://github.com/linux-rdma/rdma-core/blob/v59.0/libibverbs/man/ibv_reg_mr.3" target="_blank" rel="noopener">ibv_reg_mr</a>、<a href="https://github.com/linux-rdma/rdma-core/blob/v59.0/libibverbs/man/ibv_create_qp.3" target="_blank" rel="noopener">ibv_create_qp</a>、<a href="https://github.com/linux-rdma/rdma-core/blob/v59.0/libibverbs/man/ibv_modify_qp.3" target="_blank" rel="noopener">ibv_modify_qp</a>、<a href="https://github.com/linux-rdma/rdma-core/blob/v59.0/libibverbs/man/ibv_create_cq.3" target="_blank" rel="noopener">ibv_create_cq</a>，资源、权限与 QP 状态转换。</li><li><a href="https://github.com/linux-rdma/rdma-core/blob/v59.0/libibverbs/man/ibv_post_send.3" target="_blank" rel="noopener">ibv_post_send</a>、<a href="https://github.com/linux-rdma/rdma-core/blob/v59.0/libibverbs/man/ibv_poll_cq.3" target="_blank" rel="noopener">ibv_poll_cq</a>、<a href="https://github.com/linux-rdma/rdma-core/blob/v59.0/libibverbs/man/ibv_wr_post.3.md" target="_blank" rel="noopener">ibv_wr API</a>，提交、完成和源缓冲生命周期。</li><li><a href="https://github.com/linux-rdma/rdma-core/blob/v59.0/libibverbs/verbs.h" target="_blank" rel="noopener">verbs.h</a>、<a href="https://github.com/linux-rdma/rdma-core/blob/v59.0/providers/mlx5/qp.c#L754" target="_blank" rel="noopener">mlx5 qp.c</a>、<a href="https://github.com/linux-rdma/rdma-core/blob/v59.0/providers/mlx5/cq.c#L531" target="_blank" rel="noopener">mlx5 cq.c</a>，provider 分发、WQE 发布和 CQE 消费。</li><li><a href="https://github.com/linux-rdma/rdma-core/blob/v59.0/libibverbs/man/ibv_req_notify_cq.3.md" target="_blank" rel="noopener">ibv_req_notify_cq</a>、<a href="https://github.com/linux-rdma/rdma-core/blob/v59.0/libibverbs/man/ibv_get_cq_event.3" target="_blank" rel="noopener">ibv_get_cq_event</a>、<a href="https://github.com/linux-rdma/rdma-core/blob/v59.0/libibverbs/man/ibv_get_async_event.3" target="_blank" rel="noopener">ibv_get_async_event</a>、<a href="https://github.com/torvalds/linux/blob/v6.12/drivers/infiniband/sw/rxe/rxe_comp.c#L432" target="_blank" rel="noopener">RXE 完成与 flush</a>，通知、错误和完成策略。</li><li><a href="https://networking-docs.nvidia.com/doca/archive/3-5-0/rdma-aware-networks-programming-guide" target="_blank" rel="noopener">NVIDIA：RDMA 编程指南</a>、<a href="https://docs.nvidia.com/networking/display/mlnxenv24101140lts/rdma+over+converged+ethernet+(roce)" target="_blank" rel="noopener">RoCE</a>、<a href="https://docs.nvidia.com/networking/display/mlnxofedv24101140lts/qos+-+quality+of+service" target="_blank" rel="noopener">IB QoS</a>，操作语义、网络标识与流量分类。</li><li><a href="https://docs.nvidia.com/cuda/gpudirect-rdma/index.html#synchronization-and-memory-ordering" target="_blank" rel="noopener">GPUDirect RDMA</a>、<a href="https://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__UNIFIED.html" target="_blank" rel="noopener">CUDA 指针属性</a>、<a href="https://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__DEVICE.html" target="_blank" rel="noopener">RDMA 写入 flush</a>及<a href="https://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__TYPES.html" target="_blank" rel="noopener">能力枚举</a>，GPU 与网卡之间的同步边界。</li><li><a href="https://docs.kernel.org/core-api/dma-api-howto.html" target="_blank" rel="noopener">Linux DMA API HOWTO</a>与 <a href="https://gcc.gnu.org/onlinedocs/gcc/_005f_005fsync-Builtins.html" target="_blank" rel="noopener">GCC 同步内建函数</a>，DMA 一致性与 CPU 屏障。</li><li><a href="https://man7.org/linux/man-pages/man7/tcp.7.html" target="_blank" rel="noopener">Linux TCP</a>、<a href="https://man7.org/linux/man-pages/man2/send.2.html" target="_blank" rel="noopener">send</a>、<a href="https://github.com/torvalds/linux/blob/v6.12/net/ipv4/tcp.c" target="_blank" rel="noopener">TCP 源码</a>，socket 语义与普通收发复制路径。</li><li><a href="https://github.com/torvalds/linux/blob/v6.12/drivers/net/ethernet/mellanox/mlx5/core/en_tx.c" target="_blank" rel="noopener">mlx5 发送</a>、<a href="https://github.com/torvalds/linux/blob/v6.12/drivers/net/ethernet/mellanox/mlx5/core/en_rx.c" target="_blank" rel="noopener">mlx5 接收</a>、<a href="https://github.com/torvalds/linux/blob/v6.12/drivers/net/ethernet/mellanox/mlx5/core/cmd.c" target="_blank" rel="noopener">设备命令接口</a>与 <a href="https://docs.kernel.org/networking/napi.html" target="_blank" rel="noopener">NAPI</a>，内核网络驱动与固件的边界。</li><li><a href="https://docs.kernel.org/networking/segmentation-offloads.html" target="_blank" rel="noopener">分段卸载</a>、<a href="https://docs.kernel.org/networking/msg_zerocopy.html" target="_blank" rel="noopener">MSG_ZEROCOPY</a>与 <a href="https://www.rfc-editor.org/rfc/rfc5040.html" target="_blank" rel="noopener">RFC 5040</a>，协议卸载、减少复制和 RDMA over TCP 的区别。</li><li><a href="https://zhuanlan.zhihu.com/p/652925814" target="_blank" rel="noopener">知乎文章</a>。</li></ul>]]></content>
    
    
    <summary type="html">&lt;p&gt;围绕一次 RDMA Write，整理资源与地址、请求提交、完成队列以及驱动分工。重点区分请求提交成功、设备完成、远端得知数据到达，以及业务已经消费数据这几个时刻。&lt;/p&gt;</summary>
    
    
    
    
    <category term="网络" scheme="http://www.calvinneo.com/tags/网络/"/>
    
    <category term="RDMA" scheme="http://www.calvinneo.com/tags/RDMA/"/>
    
  </entry>
  
  <entry>
    <title>RDMA 评估指标</title>
    <link href="http://www.calvinneo.com/2026/09/18/rdma-assessment/"/>
    <id>http://www.calvinneo.com/2026/09/18/rdma-assessment/</id>
    <published>2026-09-18T14:48:32.000Z</published>
    <updated>2026-10-12T14:27:44.822Z</updated>
    
    <content type="html"><![CDATA[<p>讨论如何评估一个 RDMA 网络。</p><a id="more"></a><h1 id="主要关注点"><a href="#主要关注点" class="headerlink" title="主要关注点"></a>主要关注点</h1><ul><li>选择多个 QP 进行测试<br>  为保证顺序，同一个QP/流通常固定在一个物理成员上。多个 QP 或多流才更可能利用多条链路。<br>  同时也要看多 QP 的调度的公平性问题。</li><li>内存路径<br>  host2host / host2device / device2device / device2host</li><li>消息模型<br>  不同的大小，是否 batch</li><li>方向<br>  双向都要测，Read</li><li>拓扑亲和<br>  例如 2 QP d2d 跨 NUMA 的损失</li><li>规模并发<br>  例如多个 rail 同时</li><li>时延稳定性<br>  p50/p99、长稳、错误计数、重传、拥塞等</li></ul><p>把 -q 依次改为 1/2/4；把 ib_write_bw 改为 ib_read_bw 测读；交换 server/client 测反向。</p><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># server</span></span><br><span class="line">ib_write_bw -d mlx5_bond_0 -i 1 -x 3 -F --report_gbits -q 1 -s 67108864 -D 30</span><br><span class="line"><span class="comment"># client</span></span><br><span class="line">ib_write_bw -d mlx5_bond_0 -i 1 -x 3 -F --report_gbits -q 1 -s 67108864 -D 30 &lt;peer_rail_ip&gt;</span><br></pre></td></tr></table></figure>]]></content>
    
    
    <summary type="html">&lt;p&gt;讨论如何评估一个 RDMA 网络。&lt;/p&gt;</summary>
    
    
    
    
    <category term="AIGen" scheme="http://www.calvinneo.com/tags/AIGen/"/>
    
    <category term="RDMA" scheme="http://www.calvinneo.com/tags/RDMA/"/>
    
  </entry>
  
  <entry>
    <title>学习 KVCache：硬件和架构</title>
    <link href="http://www.calvinneo.com/2026/09/11/KVCache-learn-hw/"/>
    <id>http://www.calvinneo.com/2026/09/11/KVCache-learn-hw/</id>
    <published>2026-09-11T14:48:32.000Z</published>
    <updated>2026-10-26T16:04:17.088Z</updated>
    
    <content type="html"><![CDATA[<p>KVCache 类似于数据库中的物化中间结果：保留已有状态能省掉计算，状态不在执行端时则需要搬回来。对大语言模型，这笔搬运还要看发生频率：开始生成时 load 一次，与每步 decode 都从外部取数，会产生不同的带宽需求。</p><p>这篇笔记用一份从模型参数推导出的 4 GiB KV，串起硬件路径、搬运成本和分层缓存的设计选择。产品参数来自公开资料，工作负载与有效带宽采用明确设定的算例。</p><a id="more"></a><h1 id="KVCache-保存的状态与复用边界"><a href="#KVCache-保存的状态与复用边界" class="headerlink" title="KVCache 保存的状态与复用边界"></a>KVCache 保存的状态与复用边界</h1><p>这里的 KV 是 Transformer 注意力计算（attention）中的 <strong>Key 和 Value</strong>。文本经过分词器编码后成为 <strong>token</strong> 序列，token 是模型处理的离散单位，不与汉字或单词一一对应。在每层 attention 中，模型从各位置的输入表示生成 Query、Key 和 Value 向量，简称 Q、K、V。当前位置的 Q 与可见位置的 K 计算相关性，得到归一化权重，再用这些权重对 V 加权求和。</p><p>本文讨论的<strong>因果自注意力（causal self-attention）</strong>，只允许一个位置使用自身及此前位置的信息。“因果”这个限制，正是历史 KV 能保留的原因：后面追加一个 token，不会进入已有位置的可见范围，也就不需要改变那些位置已经算出的状态。保持模型和输入条件不变，就能保存各层的 K/V，供后续计算继续使用。</p><p><strong>Prefill</strong> 是处理本轮输入、建立对应 KV 的计算阶段。<strong>Decode</strong> 则利用已有状态逐步生成后续 token。本文默认采用<strong>稠密注意力（dense attention）</strong>，即每个查询位置都关注其因果范围内的全部位置。在这个假设下，缓存消除的是历史 K/V 的重复计算，没有消除新位置对历史 K/V 的读取。这是后面带宽分析的起点。</p><p>因此，一份 KV 的身份不只由它对应的文字决定，还取决于这段文字之前的上下文。多层 Transformer 的后续层使用已经融合前文信息的表示，同一段 token 接在不同前缀后面，不能视为同一份完整 KV。位置处理也属于计算条件，模型用它表示 token 在序列中的顺序，改变位置或位置编码方式同样会影响复用边界。</p><p>后面的算例以活跃 KV 驻留 GPU 显存为基准。文中涉及的 GPU 使用 <strong>HBM（High Bandwidth Memory，高带宽内存）</strong>，它是一种以堆叠 DRAM 和宽接口提供高带宽的内存技术。CPU 侧系统内存则记作 <strong>Host DRAM</strong>。这个区分说的是数据位置，HBM 本身也属于 DRAM。</p><h2 id="上一轮的回答也会成为下一轮的前缀"><a href="#上一轮的回答也会成为下一轮的前缀" class="headerlink" title="上一轮的回答也会成为下一轮的前缀"></a>上一轮的回答也会成为下一轮的前缀</h2><p>Prefill 和 decode 描述的是计算阶段，不是两种永久分开的缓存。看一段连续对话就很直观：</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line">第一轮输入：系统提示 + 问题甲</span><br><span class="line">第一轮输出：回答甲</span><br><span class="line"></span><br><span class="line">第二轮输入：系统提示 + 问题甲 + 回答甲 + 问题乙</span><br><span class="line">历史前缀：  系统提示 + 问题甲 + 回答甲</span><br></pre></td></tr></table></figure><p>“回答甲”上一轮是输出，这一轮已经成了输入的一部分。只要对应 token 的 KV 已经建立并保留，它就与之前的问题一样，属于本轮能够复用的历史状态。这里真正匹配的是编码后的 token 序列，角色标记、分隔符和对话模板也包含在内，不能只比较页面上显示的文字。<a href="https://docs.vllm.ai/en/latest/features/automatic_prefix_caching/" target="_blank" rel="noopener">vLLM 的前缀缓存示例</a></p><p>这段对话还藏着一个容易忽略的边界。在逐 token 的自回归生成中，模型先处理已有输入，产生下一 token 的分数，再从中选出一个 token。这个刚选出的 token 要作为下一步输入，才会建立自己的 K/V。如果生成恰好在选出它后结束，就不能把“已经输出”当作“已有 KV”。缓存按块发布时，还有完整块的边界。这里的<strong>缓存块</strong>是容纳一组连续 token 状态的管理单位，未发布的尾部不计入可复用范围。</p><p>反过来，即使输入的 KV 全部存在，也不等于能直接给出下一 token。KV 保存的是各层注意力所需的中间状态，不包含最终输出层的 <strong>logits</strong>，也就是各候选 token 在归一化成概率之前的分数。以 <a href="https://docs.vllm.ai/en/latest/api/vllm/v1/core/kv_cache_manager/" target="_blank" rel="noopener">vLLM 公开实现</a>为例，它会为取得 logits 重算输入的末尾 token。如果输入长度恰好按块对齐，而该路径只接受完整块命中，就要回退最后一个块。这是该实现的消费边界，不是所有缓存都必须采用的策略。</p><p>所以，能够跳过多少计算，要看有效状态的边界以及引擎怎样消费它，不能拿已输出的文本长度直接代替。跨请求复用还多了一段生命周期：请求结束后保留状态，下次找到它，再把需要的 KV 交给目标 GPU。这些 KV 能否持续留在 GPU，决定后续是否还需重复搬运。</p><h2 id="一份-KV-有多大"><a href="#一份-KV-有多大" class="headerlink" title="一份 KV 有多大"></a>一份 KV 有多大</h2><p>KV 容量由缓存张量的形状和元素大小决定。<strong>Attention head</strong> 是一组分别计算注意力权重和加权结果的向量通道，<code>head_dim</code> 表示该 head 中 Q/K 等向量的维度。以 <strong>GQA（Grouped-Query Attention，分组查询注意力）</strong>为例，Q head 被分组，同组的多个 Q head 共享一个 K head 和一个 V head。因此，缓存按 <strong>KV head 数</strong>计量。<a href="https://arxiv.org/abs/2305.13245" target="_blank" rel="noopener">GQA 论文</a></p><p>对于 K、V 维度相同、各层采用相同配置的常规表示，有：</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">每 token 的 KV 字节数</span><br><span class="line">= 2（K 和 V）× 层数 × KV head 数 × head_dim × 每元素字节数</span><br></pre></td></tr></table></figure><p>我选一组便于核算的参数：32 层、8 个 KV head、<code>head_dim = 128</code>，K、V 都以 <strong>BF16</strong> 保存。BF16 是一种 16 位浮点格式，每个元素占 2 byte。这组二次幂参数能让 token 数与 GiB 的换算保持直观，不指代某个线上模型。公式前面的 2 来自 K、V 两份张量，最后的 2 才来自元素字节数。</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">每 token：2 × 32 × 8 × 128 × 2 = 131,072 byte = 128 KiB</span><br><span class="line">32,768 个 token：128 KiB × 32,768 = 4 GiB</span><br></pre></td></tr></table></figure><p>取 32,768 个 token，正好得到 4 GiB。再把长度缩为四分之一，也就是 8,192 个 token，就得到 1 GiB。并发示例选 64 个请求，是为了后面能按八个实例均分，每个实例承接八个请求。这些数字只负责让工作集的变化容易核算：</p><table><thead><tr><th>示例工作负载</th><th>推导</th><th align="right">全模型 KV 有效数据量</th></tr></thead><tbody><tr><td>一个请求，8,192 个 token</td><td><code>128 KiB × 8,192</code></td><td align="right">1 GiB</td></tr><tr><td>一个请求，32,768 个 token</td><td><code>128 KiB × 32,768</code></td><td align="right">4 GiB</td></tr><tr><td>64 个请求，各有 32,768 个 token，没有共享前缀</td><td><code>4 GiB × 64</code></td><td align="right">256 GiB</td></tr></tbody></table><p>这些是全模型 KV 的逻辑载荷，未计入块内碎片、索引、预留空间和并行布局中的复制。分到每张 GPU 上的量，还取决于并行方式：</p><ul><li><strong>TP（Tensor Parallelism，张量并行）</strong>拆分同一层的张量与计算，影响每个 GPU 持有哪些 head 或分片。</li><li><strong>PP（Pipeline Parallelism，流水线并行）</strong>把不同模型层放在不同阶段，影响每个 GPU 持有哪些层。</li></ul><p>只有确认数据没有额外复制、各分片又足够均衡，才能把总量按 GPU 数平均。</p><p>这条公式的边界在于“保存完整 K/V”。例如 <strong>MLA（Multi-head Latent Attention，多头潜在注意力）</strong>通过低秩投影把 K/V 信息压入较低维的潜在向量，而不是缓存每个 head 展开后的完整 K/V。DeepSeek-V2 的公开定义还缓存一份用于位置计算的独立 Key 分量，因此连“只数一个压缩向量”也不够，仍要列出实际保存的全部张量。<a href="https://arxiv.org/html/2405.04434v5" target="_blank" rel="noopener">DeepSeek-V2 论文中的 MLA 定义</a></p><p>KV 量化又是另一种缩减。它用更少的位数表示元素，使用缩放系数的方案还要保存这些辅助数据。这里改变的是 KV 表示，仅量化模型权重不会自动缩小 KVCache。<a href="https://docs.vllm.ai/en/latest/features/quantization/quantized_kvcache/" target="_blank" rel="noopener">vLLM 的量化 KVCache 说明</a></p><h2 id="复用计算结果与扩展活跃工作集"><a href="#复用计算结果与扩展活跃工作集" class="headerlink" title="复用计算结果与扩展活跃工作集"></a>复用计算结果与扩展活跃工作集</h2><p>把 KV 保存在 GPU 外，可以服务于两种需求：</p><ol><li><p><strong>复用计算结果</strong>：让后续请求沿用已有前缀的 KV，省掉重算这段前缀的 prefill。这种用法称为<strong>前缀缓存（prefix caching）</strong>，收益主要体现在 <strong>TTFT（Time To First Token，从请求发出到收到首个输出 token 的时间）</strong>。<a href="https://docs.vllm.ai/en/latest/features/automatic_prefix_caching/" target="_blank" rel="noopener">vLLM 对前缀缓存收益范围的说明</a></p></li><li><p><strong>扩展活跃工作集</strong>：当前参与 decode 的请求每步需要访问的 KV 总体，称为<strong>活跃工作集</strong>。若请求增多或上下文变长，使它超过 HBM 中能分给 KV 的容量，就可以将部分 KV 留在外部、计算时分批搬入，从而让这些请求使用 HBM 装不下的活跃 KV。</p></li></ol><p>把已有 KV 从 Host、远端内存或 SSD 搬入目标 GPU 缓存，本文称为 <strong>load</strong>。<a href="https://docs.vllm.ai/en/latest/api/vllm/distributed/kv_transfer/kv_connector/v1/base/" target="_blank" rel="noopener">vLLM 的外部 KV load 接口</a></p><p>沿用前面那份 4 GiB 前缀，可以比较两种具体的使用方式：</p><table><thead><tr><th>比较项</th><th>复用前缀后常驻 HBM</th><th>借助外部容量扩展活跃工作集</th></tr></thead><tbody><tr><td>4 GiB KV 怎样存放</td><td>从 Host load 到 HBM，生成期间所需的 KV 都能留在 HBM。</td><td>HBM 只能常驻其中一部分，其余部分留在 Host，计算时分批搬入。</td></tr><tr><td>每步 decode 怎样读取</td><td>每步读本地 KV，这份前缀只需 load 一次。</td><td>dense decode 每步都要读取全部历史 KV，外部部分用完后腾出 HBM，下步再次 load。</td></tr><tr><td>怎样评价搬运成本</td><td>省下的 prefill 时间能否覆盖查找和 load 增加的等待，决定 TTFT 是否缩短。</td><td>每步都要搬入外部 KV，供数速度会约束生成速度。</td></tr></tbody></table><p>把 KV 从 HBM 移到 Host DRAM 或存储设备的操作称为 <strong>offload（卸载）</strong>，可用于保存历史前缀或移出部分活跃 KV。两种用途可以同时出现：请求命中已有前缀，省下 prefill，但生成期间仍因 HBM 不够而逐步 load，需要同时核算省下的计算和持续搬运的开销。</p><blockquote><p>暂停请求也是 offload 的一种用法。之后把此前换出的 KV 搬回 GPU，称为 <strong>swap-in</strong>，数据就绪后请求才能 <strong>resume</strong>，即继续运行。若这些 KV 此后持续驻留 HBM，这次暂停只引入一次 swap-in，无需每步重搬。</p></blockquote><h1 id="HBM、PCIe-与网络的数据路径"><a href="#HBM、PCIe-与网络的数据路径" class="headerlink" title="HBM、PCIe 与网络的数据路径"></a>HBM、PCIe 与网络的数据路径</h1><p>历史 KV 不在目标 GPU 上时，问题就从“省掉多少计算”变成了“沿哪条路径把状态搬回来”。这里讨论 GPU、Host 和网卡通过 PCIe 连接的服务器，其他 CPU–GPU 互连需要另算。</p><blockquote><p>统一用十进制 <code>GB/s</code>、<code>TB/s</code> 表示带宽，软件容量用二进制 <code>GiB</code>、<code>MiB</code>、<code>KiB</code>，分别对应 <code>2^30</code>、<code>2^20</code>、<code>2^10</code> byte。网卡的 Gb/s 按 bit 计量，换成 GB/s 要除以 8。</p></blockquote><table><thead><tr><th>资源</th><th align="right">容量</th><th>带宽口径</th><th>计算时需要注意</th></tr></thead><tbody><tr><td>ConnectX-7，400 Gb/s 配置</td><td align="right">—</td><td>单向标称 50 GB/s</td><td>全双工可同时发 50、收 50 GB/s，但一次单向 load 不能使用双向合计值。</td></tr><tr><td>ConnectX-8，800 Gb/s 总速率配置</td><td align="right">—</td><td>整卡单向合计 100 GB/s</td><td>全双工的双向合计为 200 GB/s。下文涉及的 2×400GbE 模式必须同时利用两个端口。</td></tr><tr><td>PCIe 4.0 ×16</td><td align="right">—</td><td>单向约 31.5 GB/s</td><td>已扣除 128b/130b 编码开销，尚未扣除事务等协议开销。</td></tr><tr><td>PCIe 5.0 ×16</td><td align="right">—</td><td>单向约 63.0 GB/s</td><td>与 Gen4 一样是单向编码后理论值，双向合计约 126 GB/s。</td></tr><tr><td>PCIe 6.0 ×16</td><td align="right">—</td><td>单向原始带宽 128 GB/s</td><td>双向合计 256 GB/s，实际有效载荷要扣除分帧、纠错和协议开销。</td></tr><tr><td>H200 SXM HBM</td><td align="right">141 GB/卡</td><td>单卡合计最高 4.8 TB/s</td><td>这是本地内存通道合计峰值，读写共享，并非各有 4.8 TB/s。</td></tr><tr><td>HGX B200 中的单个 GPU</td><td align="right">180 GB HBM3E</td><td>单 GPU 合计 7.7 TB/s</td><td>产品 datasheet 的容量与带宽口径，不是 PCIe 接收速度。</td></tr><tr><td>HGX B300 中的单个 GPU</td><td align="right">270 GB HBM3E</td><td>单 GPU 合计 7.7 TB/s</td><td>同样是本地 HBM 接口的聚合规格，不能与网络带宽相加。</td></tr><tr><td>Host DRAM</td><td align="right">按整机配置</td><td>取决于内存通道、读写组合，以及 CPU、内存页和 I/O 设备的拓扑关系。</td><td>核算这次搬运能获得的内存吞吐，并计入多路传输对同一内存控制器或跨 CPU 互连的竞争。</td></tr><tr><td>SSD</td><td align="right">按设备配置</td><td>取决于设备型号、数量和 I/O 模式，包括顺序或随机访问、请求大小与并发度。</td><td>从 SSD load KV 时，设备读取也是路径的一段，其有效吞吐要与后续网络、PCIe 一起核算。</td></tr></tbody></table><p>H200 数字来自 <a href="https://docs.nvidia.com/enterprise-reference-architectures/hgx-ai-factory-h100-h200-b200/latest/components.html" target="_blank" rel="noopener">NVIDIA HGX 组件规格</a>。B200、B300 分别采用 <a href="https://dam-cdn.nvd.orangelogic.com/AssetLink/y441155802qub41q118b2852i557jem5.pdf" target="_blank" rel="noopener">Blackwell datasheet 第 8 页</a>和 <a href="https://dam-cdn.nvd.orangelogic.com/AssetLink/1k0p832eq8r5ca0u5383ie5o4tp3bst1.pdf" target="_blank" rel="noopener">Blackwell Ultra datasheet 第 5 页</a>中 HGX 对应的单 GPU 规格。HBM3E 是表中产品采用的 HBM 代际，容量沿用厂商的 GB 标注，不当作 GiB。ConnectX 是网卡产品系列，后文把 ConnectX-7、ConnectX-8 简写成 CX-7、CX-8，速率分别依据 <a href="https://networking-docs.nvidia.com/connectx7hw/introduction" target="_blank" rel="noopener">CX-7 手册</a>和 <a href="https://networking-docs.nvidia.com/connectx8hw/introduction" target="_blank" rel="noopener">CX-8 手册</a>。</p><p>这里引用的资料存在一些规格差异：HGX 参考架构页把 B200 带宽写作“最高 8 TB/s”，产品 datasheet 的 HGX B200 一列却是 7.7 TB/s。<a href="https://docs.nvidia.com/dgx/dgxb300-user-guide/introduction-to-dgxb300.html" target="_blank" rel="noopener">DGX B300 用户手册</a>列出每 GPU 288 GB，HGX B300 datasheet 则列 270 GB。HGX 是 GPU 平台，DGX 是具体整机产品，两类资料也不应混写。以上页面没有给出足够信息让我解释这些差额，所以本文保留来源差异，算例采用表中同一份 datasheet 的容量和带宽，不自行归因到纠错或保留区。</p><h2 id="GPU-封装内的-HBM-与访存路径"><a href="#GPU-封装内的-HBM-与访存路径" class="headerlink" title="GPU 封装内的 HBM 与访存路径"></a>GPU 封装内的 HBM 与访存路径</h2><p>HBM 与 GPU 计算单元之间的距离很近，但它不是 GPU 裸片上的缓存。一个 HBM 堆叠由多片 DRAM <strong>裸片（die）</strong>垂直叠放而成，裸片指封装前的单块半导体芯片。在 B200/B300 这类产品中，HBM 堆叠与 GPU 计算裸片同处一个封装，通过高密度互连连接。<strong>中介层（interposer）</strong>是这种封装中用于芯片间高密度布线的结构之一。<a href="https://www.micron.com/products/memory/hbm/hbm3e" target="_blank" rel="noopener">Micron 对 HBM 结构的介绍</a></p><p>所以，“GPU 用 HBM”和“网卡往 GPU 搬数据”不是同一条路径。图 1 将外部搬运和封装内访问画在同一个示意中：</p><p><img src="/asset/kvcache-hw/hbm-package.svg" alt="B200／B300 封装内的 HBM 与外部 PCIe 数据路径"></p><p><em>图 1：外部数据经 PCIe 进入 HBM，GPU 计算则经封装内的内存接口读取 HBM。</em></p><p>图左的网卡可以是本文讨论的 CX 系列，例如 CX-7、CX-8。这里的蓝色箭头落在 GPU 的 PCIe 接口上，标的是<strong>接入 GPU 的那一段链路</strong>：HGX B200 的 GPU 通过 Gen5 接入，DGX B300 则由 CX-8 通过 Gen6 连接 GPU。以 DGX B300 为例，从 Host 搬数据时，前面还经过 CPU→CX-8 的 Gen5 链路，因此完整路径是“Host→Gen5→CX-8→Gen6→GPU”。从 CX-8 接收到的网络数据出发，进入 GPU 走的是其中的 Gen6 这一段。<a href="https://docs.nvidia.com/enterprise-reference-architectures/hgx-ai-factory-h100-h200-b200/latest/components.html" target="_blank" rel="noopener">HGX B200 接入规格</a>与 <a href="https://docs.nvidia.com/dgx/dgxb300-user-guide/introduction-to-dgxb300.html#dgx-b300-system-topology" target="_blank" rel="noopener">DGX B300 拓扑</a></p><p>假设命中的 KV 保存在 Host 或远端，它先从图左侧经过 PCIe 进入 HBM。等 KV load 完成且数据可用，计算沿绿色的封装内路径读取本地 KV，<strong>不再经过 PCIe 或网卡</strong>，命中片上缓存时连 HBM 也不用访问。这就解释了表里的两种带宽为什么不能互换：PCIe 衡量跨设备搬运，HBM 带宽衡量本地内存接口。SXM 只是 GPU 模块的安装与连接形态，并不是 GPU 到 HBM 的协议。</p><p>规格里的“单 GPU 合计带宽”是同一个 GPU 的各个 HBM 内存通道之和。通道内的读写共享数据线，不同通道则能并行调度，因此 7.7 TB/s 不是“同时读 7.7、再写 7.7”，也没有预先分成固定的读写份额。纯读可以利用这份总带宽，混合读写则要共同分配它，并承担方向切换等开销。这里相加的是并行通道的能力，不是把 HBM、PCIe 和 GPU 间互连这些不同路径的带宽相加。</p><h2 id="PCIe-的-lane、链路宽度与带宽换算"><a href="#PCIe-的-lane、链路宽度与带宽换算" class="headerlink" title="PCIe 的 lane、链路宽度与带宽换算"></a>PCIe 的 lane、链路宽度与带宽换算</h2><p><strong>PCIe lane</strong> 是相邻两个 PCIe 端口之间的一条全双工串行物理通路，由一对发送差分信号线和一对接收差分信号线组成。差分信号利用一对线之间的电压差表示信号，两对共四根数据信号线合起来才是一条 lane，如图 2 所示。</p><p><img src="/asset/kvcache-hw/pcie-lane.svg" alt="一条 PCIe lane 的发送差分对与接收差分对"></p><p><em>图 2：一条 lane 的物理组成。TX、RX 分别表示发送与接收，加减号标识差分对的两根信号线。</em></p><p>图中没有画参考时钟和地线。<strong>PCIe 链路</strong>由一条或多条 lane 组成，<code>×16</code> 表示这条链路使用 16 条 lane，Gen5/Gen6 表示代际，两者回答的是不同问题。器件一共有多少 lane，也不能代替某一段链路的宽度：两条 ×16 连接不是一条 ×32。数据在 lane 之间的分配由 PCIe 硬件完成，应用不会为某块 KV 指定“走第几条 lane”。<a href="https://en.wikipedia.org/wiki/PCI_Express#Physical_layer" target="_blank" rel="noopener">PCIe 物理层与链路宽度概述</a></p><p><img src="/asset/kvcache-hw/pcie-x16-link.svg" alt="十六条物理 lane 组成一条 PCIe ×16 链路"></p><p><em>图 3：×16 链路的结构示意。每条细线表示一条完整的双向 lane。</em></p><p>PCIe 5.0 每条 lane 的单向速率是 <strong>32 GT/s</strong>，这是规范标注物理层传输速率的单位，<code>G</code> 表示十亿，<code>T</code> 是 transfer。Gen5 使用 <strong>NRZ（Non-Return-to-Zero，不归零）</strong>二电平信号，一个符号表示 1 bit。它每秒发送 320 亿个符号，因此这时的符号率 32 Gbaud、规范标注的 32 GT/s 和原始比特率 32 Gb/s，在数值上恰好相同。Gbaud 计量每秒发送多少个符号，每个符号承载几 bit，则由信号编码决定。</p><p>换算只需要把单 lane 速率乘链路宽度，再扣掉编码开销。128b/130b 编码表示每传输 128 bit 内容需要占用 130 bit 链路空间。Gen4 的每 lane 速率是 16 GT/s，Gen5 是 32 GT/s，于是：</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">PCIe 5.0 ×16：32 × 16 ÷ 8 × 128/130 ≈ 63.0 GB/s</span><br><span class="line">PCIe 4.0 ×16：16 × 16 ÷ 8 × 128/130 ≈ 31.5 GB/s</span><br></pre></td></tr></table></figure><p>到了 Gen6，变化集中在信号传输和数据组织两个方面：</p><ol><li><p><strong>PAM4 让每个符号携带更多 bit。</strong> <strong>PAM4（四电平脉冲幅度调制）</strong>用四种电平状态表示 <code>00、01、10、11</code> 这四种取值，因此一个符号能携带 <code>log₂4 = 2 bit</code>。Gen6 的符号率仍为 32 Gbaud，但每个符号携带的信息翻倍，单 lane 单向原始比特率就成为 <code>32 × 2 = 64 Gb/s</code>，规范将这一代的速率标为 64 GT/s。沿着“符号率→比特率→字节带宽”换算，×16 链路得到 <code>32 × 2 × 16 ÷ 8 = 128 GB/s</code> 的单向原始带宽，双向合计为 256 GB/s。这里的翻倍来自每个符号承载的信息增加，计算已经使用 64 Gb/s 时，PAM4 的这份收益就已经包含在内。<a href="https://networking-docs.nvidia.com/connectx8hw/introduction" target="_blank" rel="noopener">CX-8 手册中的 PCIe Gen6 速率</a></p></li><li><p><strong>FLIT 与 FEC 改变了数据组织和纠错方式。</strong> <strong>TLP（Transaction Layer Packet，事务层数据包）</strong>承载设备的读写请求及返回数据，包中既有载荷，也有地址、操作类型等协议字段。Gen6 用固定长度的 <strong>FLIT（Flow Control Unit，流控单元）</strong>组织这些信息，并加入 <strong>FEC（Forward Error Correction，前向纠错）</strong>冗余来修正传输错误。因而，刚才算出的 128 GB/s 要由载荷、协议字段和纠错信息共同使用，应用实际搬运 KV 的速度还要扣除这些开销。Gen5 的 <code>128/130</code> 对应另一套线路编码，Gen6 的载荷效率需要按其 FLIT 格式和实际事务组合计算。<a href="https://pcisig.com/blog/pcie%C2%AE-60-specification-webinar-qa-deeper-dive-flit-mode-pam4-and-forward-error-correction-fec" target="_blank" rel="noopener">PCI-SIG 的 FLIT、PAM4 和 FEC 说明</a></p></li></ol><p>现在把同一份 4 GiB 放在两条路径上计算：</p><table><thead><tr><th>访问路径</th><th>采用的带宽</th><th>4 GiB 的理想耗时</th></tr></thead><tbody><tr><td>数据完整经过本地 HBM 接口，纯读</td><td>7.7 TB/s</td><td><code>4 × 2^30 / (7.7 × 10^12) ≈ 0.558 ms</code></td></tr><tr><td>从 Host 经 Gen5 ×16 搬入，只计 PCIe</td><td>约 63 GB/s</td><td><code>4 × 2^30 / (63 × 10^9) ≈ 68.2 ms</code></td></tr></tbody></table><p>按取整后的带宽相除约差 <code>7,700 / 63 ≈ 122</code> 倍。这个差值不是一次 attention 的加速比，它只说明跨过 PCIe 边界以后，同样的字节量进入了另一档时间预算。</p><h2 id="GPUDirect-RDMA-省掉了哪一段"><a href="#GPUDirect-RDMA-省掉了哪一段" class="headerlink" title="GPUDirect RDMA 省掉了哪一段"></a>GPUDirect RDMA 省掉了哪一段</h2><p><strong>RDMA（Remote Direct Memory Access，远程直接内存访问）</strong>允许适配器访问注册并授权的内存区域。以单边 RDMA Write 为例，发起方提交远端地址与访问凭据，接收端不需要由 CPU 逐字节接收、再复制这份载荷。注册建立的是设备可使用的地址映射和权限，并不是制作数据副本。<strong>GPUDirect RDMA</strong>把这类设备访问扩展到 GPU 显存，让接收网卡直接写入 GPU，而不必先落到 Host DRAM。</p><p>把三条常见路径画出来，比“是否 zero-copy”这个标签更有信息量：</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br></pre></td><td class="code"><pre><span class="line">本机已有 KV，Host→GPU 本地复制：</span><br><span class="line">本机 DRAM ── PCIe ──&gt; GPU HBM</span><br><span class="line"></span><br><span class="line">远端 KV 经 GPUDirect RDMA 直达：</span><br><span class="line">远端 DRAM ── 源端 PCIe/网卡 ── 网络 ── 目标网卡/PCIe ──&gt; GPU HBM</span><br><span class="line"></span><br><span class="line">远端 KV 经接收端 Host 中转：</span><br><span class="line">远端 DRAM ── RDMA ──&gt; 本机 DRAM ── PCIe ──&gt; GPU HBM</span><br></pre></td></tr></table></figure><p>三条路径的终点相同，区别在于数据是否经过网络、是否在接收端 Host 留下一份中转数据。</p><p>下文把 GPUDirect RDMA 简写为 <strong>GDR</strong>。它在这组比较中省掉的是接收端 Host 中转，源端取数、网络和 GPU 接入链路仍然存在。类似于存储系统里的零拷贝，关键是少做了哪一份工作，而不是给整条路径贴上“没有复制成本”的标签。</p><p>这条路径也由设备的连接方式决定。<strong>PCIe 交换器（PCIe switch）</strong>是连接多个 PCIe 端口、按地址和路由转发事务包的硬件，类似网络交换机承担的转发角色，但这里处理的是 PCIe 事务。网卡与 GPU 接在同一个交换器下，而且平台允许设备间对等转发时，事务可以直接在交换器内到达 GPU，省去 Host 中转。跨 CPU socket 的设备访问则还要经过 CPU 间互连，并满足平台的对等访问支持。判断 GDR 路径时，需要沿设备之间经过的连接来分析。<a href="https://docs.nvidia.com/cuda/gpudirect-rdma/" target="_blank" rel="noopener">NVIDIA 对 GDR 路径和拓扑的说明</a></p><h2 id="CX-8-的端口模式与-PCIe-接入带宽"><a href="#CX-8-的端口模式与-PCIe-接入带宽" class="headerlink" title="CX-8 的端口模式与 PCIe 接入带宽"></a>CX-8 的端口模式与 PCIe 接入带宽</h2><p>CX-8 的 800 Gb/s 描述网络侧的总速率。一次 KV 搬运能用到多少，还取决于这些速率分布在哪些端口，以及载荷经过怎样的 PCIe 连接。把网络入口和设备接入放到一起，才能解释整卡带宽如何变成一次 load 的带宽。</p><p>800G 首先要落实到端口模式。<strong>InfiniBand</strong> 是面向高性能互连的网络体系，与 Ethernet 不是同一套链路协议，<strong>XDR</strong> 是其中的速率代际。官方列出的 CX-8 C8180 支持单端口 800G XDR InfiniBand，其 Ethernet 模式则支持两个 400GbE 端口，C8240 的默认模式也是 2×400GbE。在这些 Ethernet 模式下，<code>2 × 400 ÷ 8 = 100 GB/s</code> 是两端口的单向合计，单独使用一个端口只能对应其中一半。<a href="https://networking-docs.nvidia.com/connectx8hw/port-configurations" target="_blank" rel="noopener">CX-8 端口配置</a></p><p>PCIe 一侧，CX-8 支持 Gen6 ×16。若实际连接为 Gen5 ×16，经过这段连接的载荷就受前面算出的约 63 GB/s 单向上限约束。假设网络与一条 Gen5 ×16 恰好串在同一次搬运路径上，仅比较这两段的理论能力，就是 <code>min(100, 63) = 63 GB/s</code>。若两端都以 Gen6 ×16 接入，PCIe 的单向原始上限提高到 128 GB/s，才有条件承接 100 GB/s 的网络载荷，实际吞吐再由内存、协议开销和共享资源决定。</p><p>目标 GPU 的接入也按同样方法核算。一份数据最终进入一张 GPU，就要经过那张 GPU 的接口。分到多个 GPU 时，每路独立的连接能够分担载荷，共用的上行则仍只提供一份带宽。这与网卡有几个端口一起，决定了整机并发传输能使用多少资源。</p><blockquote><p>延伸阅读：<strong>Socket Direct</strong> 为网卡提供两组 PCIe 接入。支持这一配置的 CX-8 型号可以通过主卡、辅助卡及连接线，把两组 Gen5 ×16 分别接入主机，聚合它们的 I/O 能力。在双路服务器上，这也能让两侧 CPU 分别访问自己的网卡接口。它是一种具体的硬件接法，需要配套型号与插槽。<a href="https://networking-docs.nvidia.com/connectx8hw/introduction" target="_blank" rel="noopener">CX-8 的主机接口与 Socket Direct 说明</a></p></blockquote><h2 id="DGX-B300-中的-CX-8-交换器与两条数据路径"><a href="#DGX-B300-中的-CX-8-交换器与两条数据路径" class="headerlink" title="DGX B300 中的 CX-8 交换器与两条数据路径"></a>DGX B300 中的 CX-8 交换器与两条数据路径</h2><p>CX-8 把 PCIe 交换功能与网络收发功能集成进同一个器件。所以拓扑图上画着 CX-8 的位置，既是网络接口，也是本机 PCIe 事务的转发节点。将这两部分展开，就能看清 Host 数据和网络数据分别怎样到达 GPU。<a href="https://developer.nvidia.com/blog/nvidia-connectx-8-supernics-advance-ai-platform-architecture-with-pcie-gen6-connectivity/" target="_blank" rel="noopener">NVIDIA 对 CX-8 集成交换器的公开介绍</a></p><p>这两类功能应分开理解。以 <a href="https://docs.nvidia.com/dgx/dgxb300-user-guide/introduction-to-dgxb300.html#dgx-b300-system-topology" target="_blank" rel="noopener">DGX B300 的公开拓扑</a>中的一个 GPU 分支为例，省略其他设备和 GPU 间互连，如图 4 所示。</p><p><img src="/asset/kvcache-hw/cx8-topology.svg" alt="DGX B300 单个 GPU 分支中的 CPU、CX-8 交换器与网络收发功能"></p><p><em>图 4：根据 DGX B300 官方拓扑及 CX-8 集成交换功能说明重绘。CX-8 内部连线只表示功能关系，双向箭头表示链路支持双向通信。</em></p><p><strong>根端口</strong>是主机侧 PCIe 层次结构的起点。从 CPU 向下读图，先到交换器朝向主机的上游端口，再由朝向 GPU 的下游端口接出。CPU→CX-8 这一段是 Gen5，CX-8→GPU 这一段是 Gen6，两段分别建立链路、协商速率和宽度。</p><p>按载荷来源展开，两条路径及其带宽预算分别是：</p><table><thead><tr><th>场景</th><th>载荷路径</th><th>需要核算的部分</th></tr></thead><tbody><tr><td>Host→GPU 本地复制，不使用 RDMA</td><td>Host → Gen5 → CX-8 的 PCIe 交换部分 → Gen6 → GPU HBM</td><td>CPU→CX-8 的 Gen5 与 CX-8→GPU 的 Gen6 两段，以及 Host 供数能力。</td></tr><tr><td>远端数据经 GDR 直达 GPU</td><td>源端内存 → 源端网卡 → 网络 → 目标 CX-8 → Gen6 → GPU HBM</td><td>源端内存与 PCIe、网络，以及目标 CX-8→GPU 的 Gen6。目标 CPU 的 Gen5 不在这条载荷路径上。</td></tr></tbody></table><p>若网络数据先写入目标 Host DRAM，后半段就仍需表中的 Host→GPU 本地复制。</p><p>把这张图对应到一台 Linux 机器上，可以使用 **<code>lspci</code>**，它是读取 PCI/PCIe 设备配置的工具。<a href="https://man7.org/linux/man-pages/man8/lspci.8.html" target="_blank" rel="noopener"><code>lspci</code> 手册</a></p><p>具体可以沿载荷路径逐段检查：</p><ol><li><strong>找到 GPU 所在分支。</strong> 用 <code>lspci -t</code> 查看设备、桥和总线的树形关系。</li><li><strong>读取 GPU 接入链路。</strong> 用 <code>lspci -s &lt;PCI地址&gt; -vv</code> 查看 GPU 及交换器对应的下游端口。PCI 地址是工具列出的设备标识，形如“总线:设备.功能”，将占位符替换为待查看的地址。输出中的 <code>LnkCap</code> 表示端口能力，<code>LnkSta</code> 表示当前协商结果，预算采用后者的 <code>Speed</code> 和 <code>Width</code>。</li><li><strong>补齐 Host 一侧。</strong> 沿设备树查看交换器上游与 CPU 根端口，记录相应的速率和宽度。将各段按载荷实际经过的顺序列出，再逐段换算带宽。</li></ol><p>例如一段当前为 32 GT/s、×8，就是 <code>32 × 8 ÷ 8 × 128/130 ≈ 31.5 GB/s</code> 的单向编码后上限，其中 32 GT/s 对应 Gen5，8 是当前 lane 数。即使 <code>LnkCap</code> 写着 ×16，这一段当前提供的仍是 ×8 的能力。</p><p><strong>NVLink</strong> 是 GPU 等处理器之间的高速互连，<strong>NVSwitch</strong> 是连接这些链路的交换器。它们与这里的 PCIe 交换器不是一回事。KV 若直接到达负责消费的 GPU，load 无需再绕 NVSwitch。若采用另一张 GPU 转发，才需要计入那段 GPU 间传输。带宽预算要按实际经过的路径来列，而不是把整机所有互连的标称值相加。</p><h2 id="Host-内存的-NUMA-位置"><a href="#Host-内存的-NUMA-位置" class="headerlink" title="Host 内存的 NUMA 位置"></a>Host 内存的 NUMA 位置</h2><p>到了 Host 一侧，关键不只是 GPU 与网卡是否邻近，还包括网卡读的是哪个 NUMA 节点上的页。典型双路服务器中，读取本网卡所在 CPU 一侧的内存，与跨 CPU 互连读取另一侧内存，经过的资源不同。设备之间的局部性与数据页的局部性，是两件事。</p><p>假设网卡和目标 GPU 都接在 CPU 0 一侧，但待传输的 Host 页在 CPU 1 一侧，载荷仍要走：</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">CPU 1 一侧的 DRAM → CPU 间互连 → CPU 0 一侧的 I/O 路径 → 网卡 / GPU</span><br></pre></td></tr></table></figure><p>0 和 1 在这里只是两个 socket 的编号。假设匿名内存采用本地分配策略，页在 CPU 1 上首次写入时分配，那么后来把提交传输的线程绑到 CPU 0，不会仅凭线程绑核就把这些页一起搬过去。页的位置受分配策略、首次触页以及后续显式迁移等机制影响，线程的位置不能代替内存的位置。<a href="https://docs.kernel.org/admin-guide/mm/numa_memory_policy.html" target="_blank" rel="noopener">Linux NUMA 内存策略</a></p><h2 id="软件并发、网络-rail-与物理-lane"><a href="#软件并发、网络-rail-与物理-lane" class="headerlink" title="软件并发、网络 rail 与物理 lane"></a>软件并发、网络 rail 与物理 lane</h2><p>前面说的 PCIe lane 是物理线路，而通信软件也会把提交或调度路径叫作 <strong>lane</strong>。后者没有统一的硬件含义，需要按软件自己的定义理解。增加这样的 lane，只能直接说明增加了并发工作或路径选择，不能说明 PCIe 多了物理线路。几个任务最终汇入同一张网卡时，它们仍共享这张网卡的能力。</p><p><strong>Rail</strong> 描述的是跨节点网络怎样分组。在按 rail 组织的集群里，每台机器上对应的一组网口接入同一组交换网络，形成一个通信平面。比如节点 A、B 各有两个网口，假设它们按下面的方式连接：</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">rail 0：节点 A 的网口 0 ↔ 交换网络 0 ↔ 节点 B 的网口 0</span><br><span class="line">rail 1：节点 A 的网口 1 ↔ 交换网络 1 ↔ 节点 B 的网口 1</span><br></pre></td></tr></table></figure><p>继续加入节点 C 时，C 的网口 0 也接入 rail 0，网口 1 接入 rail 1。这样，rail 指的是连接多台机器的网络平面，图 5 绿色区域画出的则是其中两个节点之间的一条路径。通信软件选择 rail 0，就会使用这组对应的网口和交换网络。这个概念的作用，是让“选择哪条跨机网络”有一个明确对象。<a href="https://docs.nvidia.com/deeplearning/nccl/user-guide/docs/env.html#nccl-cross-nic" target="_blank" rel="noopener">NCCL 对按 rail 组织网络的说明</a></p><p><img src="/asset/kvcache-hw/lane-rail.svg" alt="物理 PCIe lane、网络 rail 与软件并发路径的对应关系"></p><p><em>图 5：绿色区域是一条 rail 中的节点间路径，蓝色连线是节点内部的 PCIe 连接，紫色虚线表示软件任务选择网卡。</em></p><p>软件 lane 组织搬运任务，通过网卡接入选定的 rail。数据进出网卡和 GPU 时，再使用节点内部的 PCIe 链路。</p><blockquote><p>网口聚合补充：<strong>LAG（Link Aggregation，链路聚合）</strong>把多条物理链路组织成一个逻辑接口。<strong>RoCE（RDMA over Converged Ethernet）</strong>是在以太网上运行 RDMA 的协议。在支持 RoCE LAG 的硬件与驱动上，一个逻辑 RDMA 端口也能对应多个物理成员。设两条成员各为 100 Gb/s，聚合单向速率为 <code>2 × 100 ÷ 8 = 25 GB/s</code>，兑现这个总量需要流量实际分布到两条链路上。<a href="https://docs.kernel.org/networking/bonding.html" target="_blank" rel="noopener">Linux bonding</a>与 <a href="https://docs.nvidia.com/networking/display/mlnxenv24101140lts/rdma+over+converged+ethernet+(roce)" target="_blank" rel="noopener">RoCE LAG 说明</a></p></blockquote><h1 id="KV-搬运成本与分层缓存设计"><a href="#KV-搬运成本与分层缓存设计" class="headerlink" title="KV 搬运成本与分层缓存设计"></a>KV 搬运成本与分层缓存设计</h1><p>一份 KV 放在 GPU 外部，能否节省请求时间，取决于它要搬多少次、每次经过哪条路径，以及何时能被计算使用。下面沿用 4 GiB 的前缀，把传输时间、缓存生命周期和容量预算放在同一笔账里。</p><h2 id="一次-load-的字节与时间"><a href="#一次-load-的字节与时间" class="headerlink" title="一次 load 的字节与时间"></a>一次 load 的字节与时间</h2><h3 id="三条-load-路径"><a href="#三条-load-路径" class="headerlink" title="三条 load 路径"></a>三条 load 路径</h3><p>连接和内存注册已经就绪时，大块传输可以用 <code>时间 ≈ 数据量 / 有效带宽</code> 估算。远端直达的有效带宽受整条路径约束：</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line">Bdirect ≤ min(源端内存读取能力,</span><br><span class="line">              源端网卡及其 PCIe 路径,</span><br><span class="line">              网络可用带宽,</span><br><span class="line">              目标网卡及其 PCIe 路径,</span><br><span class="line">              目标 GPU 接收能力)</span><br></pre></td></tr></table></figure><p>为单独比较路径差异，给 GPU 接入和网络分别设定有效带宽：</p><table><thead><tr><th>参数</th><th align="right">取值</th><th>算例依据</th></tr></thead><tbody><tr><td>每张 GPU 接入端的有效带宽 <code>Bp</code></td><td align="right">50 GB/s</td><td>从 Gen5 ×16 的约 63 GB/s 理论值留约两成余量，取整便于计算。</td></tr><tr><td>每条独立 CX-7 网络路径的有效带宽 <code>Bn</code></td><td align="right">40 GB/s</td><td>400 Gb/s 对应 50 GB/s，再留两成余量。</td></tr></tbody></table><p>两成是算例的取整选择。这里假设 Host→GPU 复制和 GDR 写入都能达到 <code>Bp</code>，两端内存也能跟上。实际比较时，应分别测量各方向的有效吞吐。</p><p>设总数据量为 <code>S</code>，接收 GPU 数为 <code>G</code>，独立网络路径数为 <code>N</code>。在分片均衡、各路没有共享瓶颈的条件下：</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line">本地 DRAM→HBM：                 Tlocal ≈ S / (G × Bp)</span><br><span class="line">远端 DRAM→目标 HBM：            Tdirect ≈ S / min(N × Bn, G × Bp)</span><br><span class="line">远端 DRAM→本机 DRAM→HBM，串行： Tstaged ≈ S / (N × Bn) + S / (G × Bp)</span><br></pre></td></tr></table></figure><p>第三条路径要求整份数据进入 Host 后再复制到 GPU，所以两段时间相加。对一份 4 GiB KV，先把容量换成 byte：</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line">4 GiB = 4 × 2^30 = 4,294,967,296 byte</span><br><span class="line">本地 load：4,294,967,296 / (50 × 10^9) ≈ 85.9 ms</span><br><span class="line">远端直达：4,294,967,296 / (40 × 10^9) ≈ 107.4 ms</span><br><span class="line">整批中转：107.4 + 85.9 ≈ 193.3 ms</span><br></pre></td></tr></table></figure><p>再让八个独立实例同时 load，每张 GPU 各接收 4 GiB。总量增加到 <code>8 × 4 = 32 GiB</code>，需要分别看 GPU 接入和网络有没有一起扩展：</p><table><thead><tr><th align="right">接收 GPU 数</th><th align="right">独立 CX-7 路径数</th><th align="right">总量</th><th align="right">本地 DRAM→HBM</th><th align="right">远端直达 HBM</th><th align="right">Host 整批串行中转</th></tr></thead><tbody><tr><td align="right">1</td><td align="right">1</td><td align="right">4 GiB</td><td align="right">85.9 ms</td><td align="right">107.4 ms</td><td align="right">193.3 ms</td></tr><tr><td align="right">8</td><td align="right">1</td><td align="right">32 GiB</td><td align="right">85.9 ms</td><td align="right">859.0 ms</td><td align="right">944.9 ms</td></tr><tr><td align="right">8</td><td align="right">8</td><td align="right">32 GiB</td><td align="right">85.9 ms</td><td align="right">107.4 ms</td><td align="right">193.3 ms</td></tr></tbody></table><p>本地一列要求 Host 能同时提供 <code>8 × 50 = 400 GB/s</code>，且没有更窄的共享上行。第二行只有一条网络路径，传输时间就是 <code>32 × 2^30 / (40 × 10^9) ≈ 859.0 ms</code>。第三行的网络也扩展到八条，聚合有效带宽为 <code>8 × 40 = 320 GB/s</code>，时间才回到约 107.4 ms。</p><h3 id="多-GPU-分片的完成时间"><a href="#多-GPU-分片的完成时间" class="headerlink" title="多 GPU 分片的完成时间"></a>多 GPU 分片的完成时间</h3><p>同一份 KV 分散在多张 GPU 上时，计算还要等待所需分片就绪。假设把总共 4 GiB 均分到八张 GPU，每张接收 <code>4 GiB / 8 = 512 MiB</code>。七路按 50 GB/s 传输，另一路因争用只得到一半带宽，即 25 GB/s。各路同时开始，则：</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line">七个较快分片：512 × 2^20 / (50 × 10^9) ≈ 10.7 ms</span><br><span class="line">一个较慢分片：512 × 2^20 / (25 × 10^9) ≈ 21.5 ms</span><br><span class="line">整份 KV 就绪时间：max(各分片就绪时间) ≈ 21.5 ms</span><br></pre></td></tr></table></figure><p>到 10.7 ms 时，其他七路已经完成，继续提高它们的并发不能缩短最后一路的等待。如果引擎支持按层消费，则只需等待当前层依赖的分片，load 与计算才能按这个粒度衔接。</p><h3 id="Host-中转与流水化"><a href="#Host-中转与流水化" class="headerlink" title="Host 中转与流水化"></a>Host 中转与流水化</h3><p>整批中转的 193.3 ms 包含两段串行等待。要让它们重叠，可以把 4 GiB 分成 16 块，每块 256 MiB。16 是为展示流水线选的算例块数，每块接收耗时约 <code>107.4 / 16 = 6.71 ms</code>，复制到 GPU 耗时约 <code>85.9 / 16 = 5.37 ms</code>。</p><p>第一块收到后，一边复制它，一边接收第二块。复制比接收快，因而在独立缓冲区和足够内存带宽的条件下，复制端能持续跟上。网络收完最后一块后，只剩最后一次复制：</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line">流水线时间</span><br><span class="line">= 接收时间 + 复制时间 + (块数 - 1) × max(接收时间, 复制时间)</span><br><span class="line"></span><br><span class="line">本例 = 4 GiB / 40 GB/s + 256 MiB / 50 GB/s</span><br><span class="line">     ≈ 112.7 ms</span><br></pre></td></tr></table></figure><p>这里的“接收时间”和“复制时间”都是单块耗时。首块经过两段，此后按较慢的一段推进，公式因此包含启动和收尾开销。</p><p>112.7 ms 已经接近 GDR 直达的 107.4 ms，但中转仍然增加 Host 访问：</p><table><thead><tr><th>接收端的 KV 载荷访问</th><th align="right">直达 HBM</th><th align="right">Host 中转</th></tr></thead><tbody><tr><td>网络接收</td><td align="right">4 GiB</td><td align="right">4 GiB</td></tr><tr><td>写入 Host 内存</td><td align="right">0</td><td align="right">4 GiB</td></tr><tr><td>从 Host 内存读出</td><td align="right">0</td><td align="right">4 GiB</td></tr><tr><td>写入 HBM</td><td align="right">4 GiB</td><td align="right">4 GiB</td></tr></tbody></table><p>这多出的 <code>4 + 4 = 8 GiB</code> 是载荷访问量，可以循环复用较小的缓冲区完成。持续接收 40 GB/s 时，中转需要同时承担约 40 GB/s 的 Host 写入和 40 GB/s 的 Host 读取。并发任务共用内存控制器或跨 NUMA 路径时，这些访问会压缩其他任务可用的带宽。HBM 尚无空位、需要提前接住数据时，Host 中转仍能提供缓冲作用。</p><h3 id="布局与提交开销"><a href="#布局与提交开销" class="headerlink" title="布局与提交开销"></a>布局与提交开销</h3><p>以上算例只按字节量计时。实际缓存按 token 块管理，内存却按模型层和张量排列：以本文的 32 层模型为例，若每层 K、V 分开存放，一个 token 块就在 <code>32 × 2 = 64</code> 个数组中分别对应一段数据。</p><p>传输需要把这些片段变成源地址、目标地址和长度。相邻片段能合并时，提交开销可以摊薄，因此同样 4 GiB 的少量大段与大量小段，会有不同的 CPU 和设备队列开销。比较吞吐时，要同时记录总字节数、片段数和提交批量。</p><h2 id="搬运频率、排队与推理延迟"><a href="#搬运频率、排队与推理延迟" class="headerlink" title="搬运频率、排队与推理延迟"></a>搬运频率、排队与推理延迟</h2><h3 id="一次-load-与每步-load"><a href="#一次-load-与每步-load" class="headerlink" title="一次 load 与每步 load"></a>一次 load 与每步 load</h3><p>把前面两种使用方式放到同一笔账里：复用前缀后一直驻留 HBM，以及为扩展活跃工作集而每步搬入、用完后腾出 HBM。沿用 4 GiB 和 40 GB/s，只统计这份固定前缀，比较接下来 100 个 decode 步骤。取整百是为了直接看出重复搬运的影响：</p><table><thead><tr><th>KV 的使用方式</th><th align="right">外部传输次数</th><th align="right">累计搬运量</th><th align="right">累计链路占用时间</th></tr></thead><tbody><tr><td>开始时 load，之后一直驻留 HBM</td><td align="right">1</td><td align="right">4 GiB</td><td align="right">约 107.4 ms</td></tr><tr><td>每步搬入，用完后腾出 HBM</td><td align="right">100</td><td align="right"><code>4 GiB × 100 = 400 GiB</code></td><td align="right"><code>400 × 2^30 / (40 × 10^9) ≈ 10.74 秒</code></td></tr></tbody></table><p>前一种方式每步读 HBM，外部 load 主要增加首 token 前的等待。后一种方式持续依赖外部供数，会限制 <strong>ITL（Inter-Token Latency，相邻输出 token 的间隔）</strong>。重叠能减少等待，但不会减少搬运量。部分 KV 常驻 HBM 时，按实际需要从外部读取的部分计算。</p><h3 id="load-与重算的时间比较"><a href="#load-与重算的时间比较" class="headerlink" title="load 与重算的时间比较"></a>load 与重算的时间比较</h3><p>缓存命中后，请求仍要等 KV 可用。要判断是否值得 load，需要比较省下的 prefill 时间与新增的查找、准备、传输和同步时间。</p><p>固定模型、输入及 GPU 执行条件，以“前缀 KV 已在 HBM 中可用”为共同基准。假设直接 prefill 比这个基准多花 300 ms，外部缓存的查找、目标块分配及同步合计花 20 ms。两者是演算参数，用整值便于展示等待如何抵消收益。300 ms 在实际系统中应由相同输入的两种执行方式测得。</p><p>对前面那份 4 GiB KV，传输花 107.4 ms。如果整份 load 后再计算，且其他调度等待相同：</p><table><thead><tr><th>处理方式</th><th align="right">相对基准多出的时间</th></tr></thead><tbody><tr><td>直接 prefill</td><td align="right">300 ms</td></tr><tr><td>命中后立即 load</td><td align="right"><code>20 + 107.4 = 127.4 ms</code></td></tr></tbody></table><p>这次 load 能让首 token 提前 <code>300 - 127.4 = 172.6 ms</code>。172.6 ms 也就是它能容忍的额外排队时间。若 load 前排队 200 ms，总等待变成 <code>200 + 127.4 = 327.4 ms</code>，比直接重算晚 27.4 ms。选择 200 ms，就是为了越过这个临界点。</p><p>因此，请求路由需要比较各候选节点上的计算等待与 load 等待。按层预取时，则记录每层 KV 就绪和计算开始的时刻，把真正阻塞计算的等待计入首 token 延迟。</p><h3 id="持续请求与后台-I-O"><a href="#持续请求与后台-I-O" class="headerlink" title="持续请求与后台 I/O"></a>持续请求与后台 I/O</h3><p>单次 load 足够快，还需要能跟上持续到达的请求。对同一个方向，稳定服务要求：</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">load 到达速率 × 平均每次搬运量 &lt; 可用于 KV 的有效带宽</span><br></pre></td></tr></table></figure><p>40 GB/s 每次搬 4 GiB，纯传输服务能力约为 <code>40 × 10^9 / (4 × 2^30) ≈ 9.31 次/秒</code>。若每秒持续到达 10 次这样的 load，供数需求已经超过服务能力，队列会不断增长。增加 DRAM 容量只让更多 KV 留得住，不能消除这段传输排队。</p><p>KV 搬运还会与推理竞争 I/O。例如 <strong>MoE（Mixture of Experts，混合专家）</strong>把 token 路由到部分专家子网络。专家分布在不同 GPU 时会产生 I/O。当它们与 KV 搬运共用网卡或 PCIe 路径，并因带宽竞争发生等待时，后台保存就会延长前台通信，增加 ITL。</p><p>为将带宽留给正在等待数据的请求，需要限制后台传输的提交量。不过，为释放 HBM 而进行的必要换出，也会阻塞新请求入场，应按它所阻塞的计算安排优先级。</p><h2 id="分层缓存的数据复用与生命周期"><a href="#分层缓存的数据复用与生命周期" class="headerlink" title="分层缓存的数据复用与生命周期"></a>分层缓存的数据复用与生命周期</h2><h3 id="各层保存的数据"><a href="#各层保存的数据" class="headerlink" title="各层保存的数据"></a>各层保存的数据</h3><p>每步都读取的活跃 KV 需要高带宽，等待下次复用的历史前缀则更需要容量。这两种访问频率决定了各层的主要用途：</p><table><thead><tr><th>位置</th><th>主要用途</th><th>容量或访问约束</th></tr></thead><tbody><tr><td>HBM</td><td>保存活跃 KV，供 decode 反复读取。</td><td>占用权重和工作区之外的显存空间。</td></tr><tr><td>本机 Host DRAM</td><td>保留历史前缀、临时换出的请求和预取数据。</td><td>经 GPU 接入路径 load，受 NUMA 和内存竞争影响。</td></tr><tr><td>远端 DRAM</td><td>在推理实例之间共享历史 KV。</td><td>需要网络传输，并承担 load 排队。</td></tr><tr><td>NVMe SSD</td><td>保留更冷的历史 KV。</td><td>在搬运路径上增加设备读取。</td></tr></tbody></table><p><strong>P/D 分离</strong>让不同 GPU 分别承担 prefill 和 decode，prefill 结束后将 KV 交给 decode 侧。如果只服务这次生成，KV 可以直接到达 Decode GPU。</p><p>是否额外保留 Host 副本，取决于之后是否还会复用它。<a href="https://docs.sglang.io/docs/advanced_features/hicache_design" target="_blank" rel="noopener">SGLang HiCache</a>把 GPU、Host 与共享存储组织成多层缓存，<a href="https://arxiv.org/abs/2407.00079" target="_blank" rel="noopener">Mooncake</a>则研究共享 KV 与推理调度的结合。</p><h3 id="前缀身份与不可变块"><a href="#前缀身份与不可变块" class="headerlink" title="前缀身份与不可变块"></a>前缀身份与不可变块</h3><p>共享历史 KV，首先要识别同一份计算结果。前缀甲后接“你好”，与前缀乙后接“你好”，即使末尾 token 相同，KV 仍依赖各自的前文。因此，一个块的身份需要包含父前缀及当前 token 块，模型版本、位置处理等计算条件也要处于相同的复用范围。<a href="https://docs.vllm.ai/en/latest/design/prefix_caching/" target="_blank" rel="noopener">vLLM 的前缀缓存设计</a>通过父块哈希与当前块 token 等信息表达这种依赖。</p><p>对于跨请求的历史缓存，这里选择只共享完整、不可变的块。未填满的尾块由当前请求继续持有，填满后再发布。这样省去了共享尾块的写入隔离，代价是匹配前缀时少复用不到一个块的尾部，需要补算这部分。</p><h3 id="从目录命中到-GPU-可用"><a href="#从目录命中到-GPU-可用" class="headerlink" title="从目录命中到 GPU 可用"></a>从目录命中到 GPU 可用</h3><p>假设位置目录记录了各节点上报的前缀。节点上报后淘汰了某块，而目录尚未收到更新，新的请求就会找到一个已经失效的位置。即使查询时数据还在，若它在查询之后、传输之前被回收，load 也会读到错误的内存。</p><p>因此，需要在数据节点确认可用范围，并在同一个受保护的操作中取得这些块的使用引用。引用覆盖传输期间，淘汰流程才能知道哪些内存尚不能回收。目录负责定位候选，数据节点负责确认并持有实际数据。</p><p>目标端还有另一条边界：GPU kernel 正在读一块内存时，网卡同时写它，即使网卡已报告写入完成，kernel 也能观察到旧数据、部分写入或乱序结果。<a href="https://docs.nvidia.com/cuda/gpudirect-rdma/#synchronization-and-memory-ordering" target="_blank" rel="noopener">NVIDIA 的 GDR 文档</a>明确要求用相应的同步和工作提交机制保证设备间顺序。</p><p>所以，一次 load 的生命周期可以写成：</p><ol><li>确认并持有源块，分配目标块。</li><li>提交传输。</li><li>按协议确认接收完成。</li><li>满足 GPU 可见性要求。</li><li>执行所需校验或转换，允许依赖它的计算运行。</li></ol><p>这里的<strong>可见性</strong>是 GPU 计算能按同步约定读到写入结果。校验 kernel 本身也需要先满足这个条件。按层预取时，把就绪边界细化到相应层，计算就能等待当前层 KV，而不必等整份传输结束。</p><h3 id="保存完成与源块回收"><a href="#保存完成与源块回收" class="headerlink" title="保存完成与源块回收"></a>保存完成与源块回收</h3><p>把 KV 从 HBM 保存到 Host，两种用途对应不同的处理要求：</p><table><thead><tr><th>保存用途</th><th>保存失败与源块回收的处理</th></tr></thead><tbody><tr><td>历史缓存：为未来请求省计算。</td><td>保存失败可以放弃这次缓存机会，等未来重新 prefill。</td></tr><tr><td>临时换出：为当前请求腾出 HBM。</td><td>要保证之后能 swap-in 并 resume，就必须先确认目标副本可用，才能回收源块。</td></tr></tbody></table><p>两种情况都要求数据就绪后再发布为可命中。传输结束可以释放传输持有的引用，若还有其他请求读取同一块，内存仍需保留。这个回收条件与异步 I/O 缓冲区相同：最后一个使用者退出后才能复用。</p><h2 id="HBM-与-DRAM-的容量预算"><a href="#HBM-与-DRAM-的容量预算" class="headerlink" title="HBM 与 DRAM 的容量预算"></a>HBM 与 DRAM 的容量预算</h2><h3 id="活跃工作集与物理副本"><a href="#活跃工作集与物理副本" class="headerlink" title="活跃工作集与物理副本"></a>活跃工作集与物理副本</h3><p>要让活跃工作集持续驻留 HBM，需要先算出能分给 KV 的空间：</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line">单卡 KV 预算</span><br><span class="line">= 运行时报告的设备总容量</span><br><span class="line">  - 模型权重</span><br><span class="line">  - 其他激活、通信和算子的临时工作区</span><br><span class="line">  - 运行波动所需的余量</span><br></pre></td></tr></table></figure><p>模型计算产生的中间张量称为<strong>激活</strong>。若从模型加载后的空闲显存开始记账，已占用的权重就不再扣除。</p><p>沿用 64 个请求、每份 KV 4 GiB、没有共享前缀的假设，活跃 KV 共 <code>64 × 4 = 256 GiB</code>。八个单卡模型副本均分请求，每卡需要 <code>256 / 8 = 32 GiB</code> 的 KV 载荷空间。实际预留还要覆盖生成过程中新增的 token 和块内空余。TP/PP 部署则按每张卡持有的实际分片计算。</p><p>Host 保存的是历史前缀、临时换出的状态和搬运缓冲：</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line">Host KV 预算</span><br><span class="line">≈ 希望保留的历史 KV 物理占用</span><br><span class="line">  + 尚未包含在历史缓存中的临时换出占用</span><br><span class="line">  + 搬运缓冲、索引和必要余量</span><br></pre></td></tr></table></figure><p>同一物理块同时用于历史缓存和临时换出时，只占一份空间。反过来，同一份内容在 HBM 和 Host 各保存一次，就各占一份。假设 HBM 有完整的 4 GiB，Host 已有匹配的前半段，即 <code>128 KiB × 16,384 = 2 GiB</code>，补齐后的账目是：</p><table><thead><tr><th>统计量</th><th align="right">结果</th></tr></thead><tbody><tr><td>本次新增搬运量</td><td align="right"><code>4 - 2 = 2 GiB</code></td></tr><tr><td>Host 中可复用的 KV</td><td align="right">4 GiB</td></tr><tr><td>两层的 KV 载荷总占用</td><td align="right"><code>4 + 4 = 8 GiB</code></td></tr></tbody></table><p>因此，增量保存节省传输，物理副本决定容量。压缩或共享块会改变占用，预算应按实际分配的字节计量。</p><h3 id="历史前缀的复用距离"><a href="#历史前缀的复用距离" class="headerlink" title="历史前缀的复用距离"></a>历史前缀的复用距离</h3><p>保留多少历史 KV，才会让下次请求命中？可以看两次使用同一前缀之间，缓存还访问了多少其他数据。</p><p>设五份互不共享的历史前缀 A、B、C、D、E，各占 4 GiB。为了只观察容量的作用，假设以整份前缀为单位，采用 LRU 淘汰，访问未命中时将该前缀放入缓存，忽略元数据开销。访问顺序为：</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">A → B → C → D → E → A</span><br></pre></td></tr></table></figure><p>比较能存四份的 16 GiB 与能存五份的 20 GiB：</p><table><thead><tr><th>访问进度</th><th>16 GiB 缓存</th><th>20 GiB 缓存</th></tr></thead><tbody><tr><td>读完 A、B、C、D</td><td>保留 A、B、C、D</td><td>保留 A、B、C、D</td></tr><tr><td>再读 E</td><td>A 最久未访问，被淘汰</td><td>五份全部保留</td></tr><tr><td>再读 A</td><td>未命中，需要重算或从更低层取得</td><td>命中，可以 load</td></tr></tbody></table><p>两次访问 A 之间，其他不同前缀占 <code>4 × 4 = 16 GiB</code>。这就是本例按字节计的<strong>复用距离</strong>。要在 LRU 下保住 A，还需加上 A 自己的 4 GiB，因此达到 20 GiB 时，这次访问才从未命中变成命中。</p><p>新增容量的收益由访问序列决定。如果之后不再访问 A，多保留它就省不下计算。即使命中，仍要代入前面的 load 账目：本例不排队时省 172.6 ms，排队 200 ms 时反而多等 27.4 ms。</p><h3 id="并发、复用与带宽共同决定-HBM-DRAM-配比"><a href="#并发、复用与带宽共同决定-HBM-DRAM-配比" class="headerlink" title="并发、复用与带宽共同决定 HBM:DRAM 配比"></a>并发、复用与带宽共同决定 HBM:DRAM 配比</h3><p>按活跃 KV 常驻 HBM、历史 KV 保存在 DRAM 的用法，两者的容量需求由不同的负载特征决定。把前面的算例放在一起，就能看到比例怎样变化：</p><table><thead><tr><th>负载变化</th><th>容量或时间的变化</th><th>对配比的影响</th></tr></thead><tbody><tr><td>活跃请求从 64 个降为 32 个，每份仍为 4 GiB</td><td>HBM 的 KV 载荷从 256 GiB 降为 128 GiB</td><td>历史访问序列不变时，DRAM 需求可以保持不变。</td></tr><tr><td>历史缓存从 16 GiB 扩为 20 GiB</td><td>在上述序列中，A 从被淘汰变为保留</td><td>提高命中能力，活跃 KV 的 HBM 需求不变。</td></tr><tr><td>40 GB/s 路径持续收到每秒 10 次、每次 4 GiB 的 load</td><td>需求超过约 9.31 次/秒的服务能力</td><td>增加 DRAM 无法消除排队，需要减少搬运需求或增加有效带宽。</td></tr></tbody></table><p>由此，容量与带宽预算需要分别核算三项：</p><ul><li><strong>活跃 KV 的容量</strong>：从请求并发和长度求 HBM 需求。若用 DRAM 扩展活跃工作集，还要把留在外部的活跃 KV 计入 DRAM 容量。</li><li><strong>历史 KV 的容量</strong>：从前缀访问序列及复用距离求需要保留的 DRAM 容量。</li><li><strong>搬运能力</strong>：检查 load 是否能满足 TTFT 目标。若每步都从外部取数，还要核算持续搬运对 ITL 的影响。</li></ul><p>同样的硬件，改变并发、复用模式或 KV 驻留方式，就会得到不同的容量与带宽需求，因此没有脱离负载的最佳 HBM:DRAM 比例。</p><p>报告配比时，用同一组推理实例实际分给 KV 的容量 <code>H_KV:D_KV</code>。共享 DRAM 池服务多组实例时，应按整个池对应的实例集合统计，或按各组实际配额统计。</p><blockquote><p>整机规格补充：<a href="https://docs.nvidia.com/dgx/dgxb300-user-guide/introduction-to-dgxb300.html" target="_blank" rel="noopener">DGX B300 用户手册</a>列出八张 GPU，以及默认 2 TB、最高 4 TB 的系统内存。这是整机硬件容量。估算 KV 配比时，需要从系统内存中扣除其他用途，并从各 GPU 显存中扣除权重和工作区，再在相同实例范围内相加。</p></blockquote><h1 id="并发与测量补充"><a href="#并发与测量补充" class="headerlink" title="并发与测量补充"></a>并发与测量补充</h1><h2 id="在途窗口与资源复用"><a href="#在途窗口与资源复用" class="headerlink" title="在途窗口与资源复用"></a>在途窗口与资源复用</h2><p>限制后台提交量，需要同时看在途字节和操作数。<strong>在途字节量</strong>是已经提交、尚未完成并归还窗口额度的载荷总量。字节窗口约束数据压力，操作数上限约束大量小片段带来的提交和完成处理开销。</p><p>稳定运行时，Little 定律给出平均在途量约为 <code>B × L</code>：<code>B</code> 是目标吞吐，<code>L</code> 是从提交到归还额度的平均时间。沿用 40 GB/s，假设完成周期为 100 微秒，得到 <code>40 × 10^9 × 100 × 10^-6 = 4 MB</code>，约 3.81 MiB。100 微秒是用于算例的整值，<code>L</code> 包含通知处理与调度时间。</p><p>窗口需容纳这部分工作，才能让设备持续有数据可传。设备已经持续满载时，再扩大窗口会增加排队，此时应观察前台等待是否增加。</p><p>准备操作也能占用 load 时间。预注册内存池把页面就位、固定页和 RDMA 注册摊到初始化阶段，连接池则复用 <strong>QP（Queue Pair，RDMA 的发送与接收队列对）</strong>和已交换的端点信息。它们分别减少内存准备与建连开销。<a href="https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/#pinned-memory" target="_blank" rel="noopener">CUDA 固定页内存</a>与 <a href="https://docs.nvidia.com/cuda/gpudirect-rdma/#registration-cache" target="_blank" rel="noopener">GDR registration cache</a></p><h2 id="带宽的计时范围与推理收益"><a href="#带宽的计时范围与推理收益" class="headerlink" title="带宽的计时范围与推理收益"></a>带宽的计时范围与推理收益</h2><p>同一份数据，除以纯传输时间与除以整个 load 调用时间，会得到不同的吞吐。沿用前面的 4 GiB 算例：</p><table><thead><tr><th>计时范围</th><th align="right">时间</th><th align="right">有效吞吐</th></tr></thead><tbody><tr><td>只计传输</td><td align="right">约 107.4 ms</td><td align="right">约 40 GB/s</td></tr><tr><td>加上 20 ms 准备与同步</td><td align="right">约 127.4 ms</td><td align="right"><code>4 × 2^30 / 0.1274 ≈ 33.7 GB/s</code></td></tr></tbody></table><p>减少准备时间会提高第二个数字。测量时需要注明是否包含排队、内存注册、建连与同步，并区分 Host→GPU 和 GPU→Host 的方向。</p><p>测量目标不同，对应的比较方式也不同：</p><ul><li><strong>单次复用收益</strong>：固定模型和输入，比较 load 与重算的 TTFT。</li><li><strong>搬运干扰</strong>：在相同请求负载下加入后台搬运，观察正在生成的请求的 ITL 增加多少。</li></ul><p>记录入队、提交、接收完成、GPU 可用与计算开始的时间，才能把等待落到对应阶段。并发测试还需观察延迟分布，避免平均吞吐掩盖少数慢分片或突发排队。</p>]]></content>
    
    
    <summary type="html">&lt;p&gt;KVCache 类似于数据库中的物化中间结果：保留已有状态能省掉计算，状态不在执行端时则需要搬回来。对大语言模型，这笔搬运还要看发生频率：开始生成时 load 一次，与每步 decode 都从外部取数，会产生不同的带宽需求。&lt;/p&gt;
&lt;p&gt;这篇笔记用一份从模型参数推导出的 4 GiB KV，串起硬件路径、搬运成本和分层缓存的设计选择。产品参数来自公开资料，工作负载与有效带宽采用明确设定的算例。&lt;/p&gt;</summary>
    
    
    
    
    <category term="机器学习" scheme="http://www.calvinneo.com/tags/机器学习/"/>
    
    <category term="AIGen" scheme="http://www.calvinneo.com/tags/AIGen/"/>
    
    <category term="LLM" scheme="http://www.calvinneo.com/tags/LLM/"/>
    
    <category term="aiinfra" scheme="http://www.calvinneo.com/tags/aiinfra/"/>
    
  </entry>
  
  <entry>
    <title>南非游记</title>
    <link href="http://www.calvinneo.com/2026/08/09/meet-in-south-africa/"/>
    <id>http://www.calvinneo.com/2026/08/09/meet-in-south-africa/</id>
    <published>2026-08-09T15:09:06.000Z</published>
    <updated>2026-09-10T15:49:57.796Z</updated>
    
    <content type="html"><![CDATA[<p>7.28-8.08</p><p>总的来说这是一次很幸运的旅行，因为我们的大交通航班都没有延误，并在在南非的每一天都是晴天，这是非常难得的。我感觉我们去的时候已经在往旱季过渡了。</p><p>从体验上来看，因为南非是右舵，所以无法自驾。并且这个国家其实治安确实挺差的，我们只能跟团玩。跟团玩的体验其实是非常不够深入的，基本上都是坐车。我只能在夹缝间去尝试和当地人聊聊天啥的。</p><a id="more"></a><h1 id="行前准备"><a href="#行前准备" class="headerlink" title="行前准备"></a>行前准备</h1><p>我想去南非是因为看到了 B 站上司徒小韩的视频，后面又看到了小钟的视频，就对非洲起了兴趣。因为当时伟哥也在卢旺达，他很推荐我来非洲跟团，所以我就打算去非洲了。我原来准备直接肯尼亚大迁徙的，但是怕那边有传染病，最后选择了疾病意义上更安全的南非。</p><p>我知道有深圳出发的直达的 CA867 航班，但是因为他要 12/13h，并且我很讨厌中国航司的起飞和降落前 30min 不能动的规矩，所以我更希望去走 EK 中转迪拜先去开普敦的团，但是那样的团很少，我们先找了一家 730 的，但是定金都交了，那个团说满了，结果只能作罢。</p><p>后面，我又看了下去埃及或者摩洛哥的团，最后还是想去南非。因为这两个同样也很远，并且这两个地方夏天还很热，我希望南非能够舒服一点。所以最后墨迹了半天，还是报了 CA867 的团。</p><p>尽管被建议带一些方便面或者零食，但是我认为我是很能接受西餐的，所以我就带了两包鱼趣，一袋饼干，五包旺仔 QQ 糖出发了。我妈倒是带了一包老母鸡汤面，一堆豆干。</p><h1 id="D0-深圳"><a href="#D0-深圳" class="headerlink" title="D0 深圳"></a>D0 深圳</h1><p>在南京值机的时候，柜台表示没见过我们这种第一程在第一天，第二程在第二天的航班，她不知道怎么算入境时间，我们等了好久才帮我们值了机。我让他帮我选了 A C，她说大概率中间还有人。</p><p>我们是 CA3370，飞机在天上盘旋了一个小时才到达。</p><p>到了之后，wyp 已经在机场等我们了。我们于是打车去大仟里，在大榕树下顺德菜吃了，他家的鸭子还是挺不错的。</p><p>吃完饭，我们骑车从大仟里，深圳这边骑车还是挺舒服的，我们基本上沿着沿江高速高架下面骑。到了欢乐港湾我们就此别过，在欢乐港湾我们逛了会，然后就打车去腾讯大铲湾总部。在总部逛了一个小时，感觉这边还挺新的。</p><p>晚上和 bp 哥吃了八合里，然后蹭了下他羽毛球场的淋浴洗了个澡，不得不说这个淋浴房很好，不仅有五六个莲蓬头，还有一个残疾人用的，可以做下来的淋浴房。不过残疾人可以打羽毛球么？然后又参观了下他的宿舍，其实我们下午就已经走到了那里还上了个洗手间。那边挺好的，租金也就 3000 不到。不过那边说大堂会漏水，质量很差劲。然后我们就打车去机场。</p><p>晚上到了机场，向导刚好也到了。我们去那边拿了插头，他确实给了我们一个类似的多用插头，但是拆卸起来更方便，另外给我们一个脚特别粗的南非专用的三角头。我们遇到了一对老夫妇，他们在问另一个团队的领队，是不是姓王。我找过去问，你是不是找 wjw，那我们就是一个团队的，他说是的。后来我们聊了下，他们其实 80 年代就去澳大利亚创业了，定居在墨尔本。他们这次到中国先在广州逛了逛，然后来深圳去南非，再回来在广州逛逛。</p><p>在出海关的时候，我被拉进了小黑屋，把我包一顿翻，结果只是领队刚给我的万用插头。<strong>我觉得他们工作挺不好的，这东西都不能通过机器标注出来，我对他们进行了抱怨，他们好像比我还生气，一个戴眼镜的对我呵斥说“你服从就行了”，所以我对深圳海关印象非常差，好像我们公民跟他有仇一样</strong>。然后我妈的充电宝说是召回批次也被扔掉了，但是南京就可以过，不知道怎么回事，所幸安克可以直接退款。</p><p>我们是 A C，中间坐了一个去南非出差的男的。这个男的感觉有点神游，一直说话前言不搭后语。我们的飞机基本是正点出发的，这也意味着我们要准点甚至提前点到。</p><p>整个飞机中途有两餐，整体体验还是不太绷得住的。我想把椅背放倒睡，结果后面一个老头有意见，把我弄起来了，我就稍微少靠了点。但是过一会，前面的椅背又压下来了，结果我这次没办法，就和老头说你去找前面人吧。</p><h1 id="D1-飞机-约翰内斯堡-比勒陀利亚"><a href="#D1-飞机-约翰内斯堡-比勒陀利亚" class="headerlink" title="D1 飞机-约翰内斯堡-比勒陀利亚"></a>D1 飞机-约翰内斯堡-比勒陀利亚</h1><p>南非传说过关很慢，偏偏我们团队的几家五口好像在下飞机的时候迷路了，导致其他团队都走了，我们团队都没有集合完成。我们在登机口等了一会，并没有等到。这个时候，我在琢磨着如何定位，因为我发现我的 Location Service 一直显示定位不了，重启也无法解决问题。后来发现，需要连一次 wifi 才行。后面看了下小红书，可能是国内卡的国际漫游服务的坑。</p><p>向导之后自己带我们先去过关，然后微信留言（打不通电话）让他们跟上。我们走到口子那里，发现右边已经排了一坨人了，不过全是欧美样子的，应该和我们这种要签证的不是一类。原来我们去非洲要么办个人签证 ETA，要么办团队签证 TTOS。然后我们向导好像找了个理由，说我们团队既有 eVisa，又有 ETA，他就拿着这个理由去问了一个 officer，officer 就把一个 ETA 的易拉宝移到一边，我们就走一个口子绕开了排队，直接走到了绕来绕去的那个排队栏杆的尽头。不过我们前面还有一些从这个栏杆的其他出口出来的人，我们前面的窗口大概是 24-28 这几个窗口。向导问了半天，也不知道我们要去办哪个窗口。这边的布局大概是最左边是本国人的，最右边是欧美人的，这两边的队伍都很长，但是速度比较快。中间的一些是给 ETA 和 TTOS 的，大概开了两三个窗口，都不知道在办啥业务，也就排了五六个人，但是挺慢。我们等了一会，向导说是 28 号窗口，这个时候合肥的也过来了，向导赶快让他们跟在我们后面。又过了一会，我看到 24 号附近又有人在喊 eVisa，我就让向导过去看下。向导过去一问，说过去一半到那边去排，我就过去了。向导然后就自己先过关了，说帮我们拿行李。我们又等了一会，24 号窗口才把前面的那些人消化掉。那些人也挺麻烦的，比如有人被问酒店是哪里，有人被问年龄多大（officer 自己算不来），然后我们这边就在要我第一个走，帮他们都翻一下。不过我向导说不会问任何问题，因为资料都提交过了。果然，我们过关就很快，而且也给我们敲了章。</p><p>我算是前几个入境的，在行李转盘那里等了很久。行李转盘那里，一个黑人马达母一直在喊 china china，要我们自己去 carousel 上取行李，和小钟说的一样。最终，我们八点半不到就全都入境了，向导说已经破纪录了，这一切都因为自己插了个队。然后他下午又说，有的团队今天花了 3 小时才入境。无论如何，我们入境的时候地接导游还没到呢。我去上了个厕所，这边厕所的尿池都很高。马桶间的门的底部都露出一个特别高的缝隙。出海关，这边地面上铺了南非国旗用到的六个颜色。到了机场到达大厅，导游来了，但是车好像还没到，所以我们又在机场二楼逛了一圈，有人买了一些咖啡，我担心信用卡盗刷问题（后来发现在这些场所不会盗刷）就没有买。</p><p>九点车到了，我们要出机场，稍微走一段，到另一个停车场去上车。这个车看起来特别新，里面有一股松香一样的消毒水的味道，每一个座位上也都套了黑色的罩子，导游说这个是 2010 世界杯用车，只是后来翻新过了。</p><p>这个机场叫 OR Tambo 机场，我们团里面基本都把他当成曼德拉了。在机场到达大厅，有一个他的雕塑，在机场外面，有一个更高的他的雕塑，导游说这个人就是曼德拉被关起来的时候，主持非国大的人。然后就是一路向北，开到比勒陀利亚。一路上就是感觉金黄金黄的，部分地方还有烧焦的痕迹。司机是一个黑人小哥。开了一会就到了第一个景点。然后我们下车的时候，导游叫我们把值钱的东西都带上，我看好像他们都会下车，只留一个司机，于是我只能把 ipad 和望远镜都背上了。</p><p>今天的第一个行程是比勒陀利亚的先民纪念馆，这个其实就是布尔人建的历史纪念馆，主要描述他们和黑人部落的战争历史，并且有意省略了他们被大英帝国爆锤的历史。当然，在对面远处另一个山丘上，还有个黑人的纪念馆，上面有很多旗杆那样的，不过一般没有旅游团会去。当我们去的时候，同时也有一个高中学校的很多学生在参观，他们分成了很多团，但是我感觉应该是一个学校的多个班，因为校服都一样。导游和我们说他们大概是某个私立学校的，因为他们大多是白人，我看只有一个黑女生。然后导游后面车上也和我们说现在南非虽然没有种族隔离了，但实际上也没有实现我们想象中的种族融合，很多有钱的白人还是上自己专门的语言学校，比如用荷兰语教学，从而实现和别的族群的隔开。我后面凑近了听高中生的讲解员，发现他们的语言好像德语，我感觉应该他们就是布尔人吧。</p><p>这个先民纪念馆的浮雕是主要讲解对象，具体讲了啥我就不展开了。这个导游还是讲的不错的，很浅显能把大家讲明白。比如他对每一幅画都进行了最抓眼球的解说，例如第一幅画中是如何融入了雕刻师的脸的，在哪一幅画中有当时还是小孩子的克鲁格，头上有个瘤的祖鲁国王出现在哪几张图中，那个翻译官的角色，比勒陀利乌斯是如何的幸运，血河战役，和另一个祖鲁国王进行合纵连横分化黑人，最后和英国签订条约。壁画结束之后，还讲了这个这个建筑本身，比如太阳会正午射进来之类的，随后我们就开始自己活动。</p><p>值得一说的是，这个纪念馆有个地下室。我一开始准备下去的时候，那边有很多学生在楼梯口，我就想走了，但是那边的女老师非常热情地问我要不要下去看，并且让学生们给我让出一条路。不过我感觉确实也碍着他们事，不如等会了，所以我又上来了。</p><p>地下室里面可以看到浮雕的原图，不过其中有一个细节修改了，就是一个浮雕上面的黑人原来是要摔一个小孩子，但是正式版本中被换成了火炬。地下室里面还有一些陈列，包含了浮雕中涉及到的人用过的物品，还有一个很大的刺绣展览馆，里面的东西都是可以卖的，但是价格很贵，小的要几千兰特，大的要几万。他们刺绣很多用的线都很粗。</p><table><thead><tr><th align="center">刺绣</th><th align="center">刺绣局部</th><th align="center">壁画</th></tr></thead><tbody><tr><td align="center"><img src="/img/SA/cx.png"></td><td align="center"><img src="/img/SA/cxjb.png"></td><td align="center"><img src="/img/SA/bh.png"></td></tr></tbody></table><p>地下室里面东西还挺多的，比如一进去的地方还陈列了厨房的样子，然后一间屋子里面还有豹子的标本。我在快速探索，忽然砰地一声，我头撞到了一个木头棒子搭起来的门框上。贼疼，瞬间就肿起来了，后面看还流血了，把旁边的学生都惊讶到了。然后我们坐电梯走到这个纪念馆的顶部，出去看了一下比陀各个角度的样子，感觉这个城市的高楼大厦并不多，建成区也不大，很大的地方都是荒地。这里还贴心的标注了你看到的不同地点都对应了什么，还标出了 air force 基地。</p><p>从纪念馆出来，我们就去吃中饭，这是一家叫顺德的餐馆，但是它卖的菜和顺德一点关系都没有，影响最深刻的是狂加味精的紫菜汤。这家餐馆是在一个赌场旁边的。我们今天的团餐是中餐，基本上就是经典的第一道菜，紫菜蛋汤。他们家的紫菜蛋汤，味精和不要钱一样，放了非常多。总的来说，团餐还是不错的，不过我并不喜欢在国外吃中餐，而是更希望体验下当地的食物。而我们的大部分团友，尽管可能去了多个国家，但是在语言和饮食上还是渴望一个中文的环境。</p><p>吃完饭，我们就去总统府。其实去总统府的那一条路是挺好的，据说如果我们十月份过来，就正好是这边的春天，那么就可以看到蓝楹花盛开。</p><p>其实总统府进不去，或者说只有本地居民在预约之后能进去。我们去的是总统府一路之隔的那个广场，往下走有个曼德拉的铜像。这里其实没啥好看的，除了铜像，就是一些草坪。在左边草坪的端头，还有个铜像，但是我不知道是谁。在总统府的那个山上，掏出望远镜看，还能看到远处山上的先民纪念馆。</p><p>从总统府出来，我们就车观了比陀市区，包括它的已经关闭了的市政厅，以及对面的自然博物馆。一路上看到的都是流浪汉，导游说这边原来是想打造成景点的，但是因为流浪汉太多，所有的旅行社都不会让客人在这里下车。导游说这边的房子基本上都挺老了，基本都是白人南非的时候建造的，说这边的房子其实很难被拆掉，法律流程很繁琐。导游还说了一些趣事，比如，做曼德拉雕塑的时候，是不允许雕塑家留名的，但是雕塑家把自己名字刻在一个小鸟上，放到了曼德拉的右边耳朵里，结果瞒天过海，很多年后才被发现。</p><p>晚上住在一个非洲风情酒店，实际上就是一个房间是一个屋子，不过这个屋子是茅草屋特色的。我们团被分在 7xx 房，其中我们的是 701。这边人非常热情，我们下午出来散步的时候，基本每个人都会和我们打招呼。原来我以为是服务人员这样，后面才发现他们这边人好像都这样。虽然说这个酒店很大，但其实也没有那么大。这里有很多 sightseeing，比如 elephant in the mist，然后我怀疑这些其实就是几个雕塑这样，或者我都不知道那边为啥能取这个名字。这边导游和我们说最好早点洗澡，防止晚上没有热水，所以我们就下午洗澡了，不过晚上也是有热水的。南非这边酒店的莲蓬头很少有能拿下来的，所以我洗澡就很不方便，因为我的头现在还不太能进水。然后这酒店和我们之前在挪威 Flam 一样，是两个龙头要双重控制，很不方便，最后我发现把热水开到最大，调节冷水就行。然后这个酒店里面还有浴缸，但是我们也不会用的。我也往洗脸盆里面倒了点水，看南北半球的漩涡是不是不一样，但是我发现水直接就下去了，根本没有漩涡产生。</p><p>反正我们前前后后逛了两趟，基本这个酒店都逛下来了，大部分都是客房而已。我们甚至绕来绕去找到了晚上要过去吃的饭店。</p><p>晚饭是百兽宴。首先先上了个南瓜汤，然后就上了一圈酱料和面包，面包就着很硬的黄油吃还挺好吃的，我吃了不少。然后上了两个像玉米面糊糊一样的东西，吃起来没有味道，要浇着旁边的红色酸甜酱在上面一起吃。这个东西南非有个什么名字，但是它还有个名字叫恩希玛，我在 b 站老看到。</p><p>接下来就是吃肉环节，会上一个热的铁盘子，然后不停有人拿着签子过来说你要不要吃什么什么肉。吃了羚羊肉、鳄鱼肉、长颈鹿肉、斑马肉。斑马肉好柴，黑乎乎的，或者说烤的太焦了。长颈鹿感觉没熟，或者说长颈鹿肉里面有点软烂，像炖过的，虽然外面已经很老了。吃长颈鹿的时候，切肉小哥帮我加了一勺红色果冻酱，说就要就着这个吃。我们和这个小哥合了影，此外，之前吃鸡肉的时候也合了个影。羚羊肉挺好吃的，我吃了羚羊肉的肉丸，肠，还有一个很有趣的是饺子，感觉它里面加了很多香料，吃起来很咸加上一股味精的感觉，让我莫名联想到洗衣粉，我不知道为啥，可能是啥童年记忆吧。另外，还有一些咖喱饭，以及这边很喜欢吃的鸡肝一锅炖。我们还买了一瓶啤酒喝了下，也不是很贵，大概 60 兰特，我们从开普敦回来，才把钱给到导游。吃完之后，这边的特色是要把一个南非国旗降下来，这也就说明你投降了。然后就会帮你把盘子撤掉，换成一个小甜品。</p><table><thead><tr><th align="center">长颈鹿</th><th align="center">斑马</th><th align="center">鳄鱼</th></tr></thead><tbody><tr><td align="center"><img src="/img/SA/r_cjl.png"></td><td align="center"><img src="/img/SA/r_bm.png"></td><td align="center"><img src="/img/SA/r_ey.png"></td></tr></tbody></table><table><thead><tr><th align="center">羚羊丸子</th><th align="center">蜜汁猪肉</th><th align="center">啤酒</th></tr></thead><tbody><tr><td align="center"><img src="/img/SA/r_ly.png"></td><td align="center"><img src="/img/SA/r_mzzr.png"></td><td align="center"><img src="/img/SA/pijiu.png"></td></tr></tbody></table><table><thead><tr><th align="center">咖喱饭，里面肉是啥忘了</th><th align="center">饺子</th><th align="center">面包</th></tr></thead><tbody><tr><td align="center"><img src="/img/SA/r_fan.png"></td><td align="center"><img src="/img/SA/r_jiaozi.png"></td><td align="center"><img src="/img/SA/mianbao.png"></td></tr></tbody></table><p>我们下午在酒店洗了衣服，导游说这边很干，但是第二天还是有一点点湿气的。</p><p>回到酒店，打开电视，这边也有好多台，但是感觉清晰度真的好差。</p><h1 id="D2-比勒陀利亚-兰赛利亚机场-开普敦"><a href="#D2-比勒陀利亚-兰赛利亚机场-开普敦" class="headerlink" title="D2 比勒陀利亚-兰赛利亚机场-开普敦"></a>D2 比勒陀利亚-兰赛利亚机场-开普敦</h1><p>酒店早饭挺不错的，这是一个圆形的宴会厅。在最左边，可以点鸡蛋饼，鸡蛋饼里面可以加很多东西，我说 i want all of it，所以就加了番茄碎、洋葱碎、黄瓜碎、奶酪、chili、香菇、青辣椒等，吃起来挺带劲的。这里还有两种的豆子汤。中间的摊位是在做华夫饼，我过去的时候，那人已经连续做失败两个了。</p><p>今天早上先去狮子园，然后去民俗园，这两个地方就是面对面。</p><p>在狮子园，会坐那种有顶的，旁边有网的喂食车去逛大概 2h。走的时候我看了下价格，自驾 R300，2h 有向导的 R 705。可以理解为类似上海野生动物园的猛兽区喂食车，不过要便宜很多，并且也能看更多东西。</p><p>我们的司机+ guide 是一个黑人小哥，这个时候向导还吐槽了一下，说本来司机和 guide 是分开的。不过这个向导的情绪价值挺高的，经常讲段子。比如说狮子喜欢吃 mother-in-law。</p><p>一进去首先看到的就是鸵鸟，它晃晃悠悠的，一开始我们以为它要走了，结果他过了个马路，我们找到了很好的角度。然后是野狗，wild dog。向导说它们很危险，会攻击人类，然后它们会在左边那个水坑里面撒尿，但是同时又会从那里面喝水。我问所以 wild dog 不能被 cultured 了，那你们如何喂食呢？他说是的，所以只能把肉扔在地下吃。</p><p>随后，那个黑人小哥发现我能讲英文，就问我想看啥，我就说已经看了的都挺不错的，我们想看各种动物，包含狮子。然后往前走，我们就看到了狮子。然后这个狮子非常给面子，就开启了 fuck 模式。guide 讲解说狮子一天能做几百次，但是每次就一分钟左右。然后说这个狮子有四个老婆，所以可以说非常累了。</p><p>后面的行程就是一直往前走，看不同的狮子。我们一共看了五六个狮群，然后回程又会简单再过一遍。这些狮群里面还有一些是白色的狮子。这些狮子一般都在树荫下发呆，就和我家猫一样，我们向导还拍到了狮子打瞌睡的一幕。但是也有个别狮子会在我们车子旁边绕行。其中有一个领地意识最强的看到我们车就在旁边一边高声吼叫（非常低沉的声音，感觉汽车都在震动）然后一边巡视，这个体验我们在国内肯定是没有过的，我们也拍下来了。</p><p>在旅程接近返程的地方，我们可以下车，走到外面去看被铁栅栏隔开的狮子，以及猎豹花豹和鬣狗。这里的狮子感觉就有点暴躁，一直在巡视领地，大家都有点害怕。在豹子区，向导还帮我们拍视频，感觉他还是可以的。我们最后还和他进行了合影，我又趁机教他说了 niubi。</p><p>看完豹子就会回去了，guide 和我说今天运气不是很好，没看到长颈鹿，向导和我们说，等到了克鲁格，长颈鹿实际上是非常多的。回程之后，向导示意可以给小费，我确实打算给一点，但是我全身只有 100 美元的面额，只能作罢。</p><p>从狮子园出来，我想到之前在挪威峡湾的事情，就问导游这个狮子园是私人的，那么税高么。他说空着不弄就不要上税，如果弄了东西，就要看你挣多少钱来上税了。我感觉这个比挪威还是友好一点的，然后墨尔本的夫妇说，墨尔本也这样，要上地税，每年还涨价。但是如果你只有一套房子，那就还好。</p><p>进了民俗村，首先是非洲腰鼓互动，基本上就是她教你打很多节奏，然后就是你打你的节奏，她打她的节奏，然后合作成一个乐曲。互动完，就带我们去逛民俗村。不过我们导游让我们跟他走，我们在每个人身上贴了个绿色标，然后我们就从最后一个民俗村开始逛起来。</p><p>逛完四个民俗村，我们就去吃饭，表演在一点钟开始。第一个村子是 pedi 村，一进去，那边的村民就点了篝火，然后我们围着篝火坐下来，导游就开始用中文讲解。期间，村民拿了一个盘子过来，导游摇了摇手，我走过去看，发现是焦黑的像虫子一样的东西。我们没人敢吃，反倒是那个村民小哥吃了个。第二个村子是 xhosa 村，挺有名的，因为这个是曼德拉的部落。我们在门口等了一会，因为上一个团队还在听门口土著的讲解，然后我们进到一个小屋里面，导游要我们男女分开坐，因为门的开口朝着男人，这样如果敌人进来之后，男人就可以防御。然后一个小姐姐进来唱跳了一下，然后就出去了，导游在里面介绍曼德拉，然后那个小姐姐一会又进来了，催我们走。导游一开始没理她，但是明显他加快了。很快我们出去了，发现外面依然堵的全是人，那个土著男递给导游一大一小两个铁拐杖，跟他说 tell them about the pipe。导游问有人知道这是啥么，我说这是烟斗。导游说，你们猜猜哪个是男人用的，哪个是女人用的？我们说大的是女人用的。然后导游就解释为什么女人用大的。下面一个村子是 sotho 村。这里中间有个十字形的台子，导游问我们这是做啥的，我说做烧烤的，对了一半。其实这个是做饭用的，根据风向，可以选择在十字划分出来的某个象限去生火做饭。这里的院子里面还有一个女人在磨东西，我去尝试磨了下，感觉很累，因为你要压得特别紧才能磨出来。我拿了三粒米回去。最后就是祖鲁族了，他们的房子挺有趣的，都是圆顶的，而其他族的是尖顶的。导游说祖鲁族的人比较喜欢打仗，所以他们部落里面的小伙子都拿着武器。很多人都跑过去合影，我看到其中一个小伙子身上纹身了一个“命”，我就指了一下，结果那个小伙子就念了出来：ming。我说你 you do know chinese，他说 a bit。</p><p>逛完四个村子，就是吃饭。这里午饭种类还是比较丰富的，影响深刻的是牛肉和羊肉都是比较鲜美的，并且也有昨天那个恩希玛可以吃。然后这里面有个面包也很好吃，有点我小时候吃的那个肉狗肠的外面的那个面包的感觉，可惜是冷的，所以风味下降了一些。</p><p>吃完饭正好一点，可以过去看表演。其实我们进去的时候已经有不少人了，不过如果往上面坐一点，还是能够正面看到演员的。我们在一个黑人和一个白人小姐姐中间看到两个座位，问了下没人坐，我们就坐下来了。这边的舞蹈还是很欢快的，我感觉非洲人可能不是很喜欢工作，但他们一定很喜欢跳舞，每个人跳舞都非常卖力。其实每个舞蹈之前，都有主持人讲解是什么的，比如有 panty man 和 panty women。不过舞蹈感觉都是大同小异，比如有很多高抬腿往下砸的动作，后面主持人说这个就好比用拳头砸在敌人的胸口。不过我很好奇为什么他们高抬腿了几次之后，一定要摔一跤呢？还有很多是不停在地上翻滚的。每次有人出来做这样的表演，黑人们都会爆发出一阵欢呼，我其实也没有很明白。看完表演之后，主持人说要来自什么什么学校的学生先坐着，我才知道这些人其实也是一个学校出来的。</p><p>从民俗村出来，我们就出发去机场。这个机场是一个很小的机场，可以理解为在安检完就是一条长廊，然后分布了很多登机口。这边安检挺好，东西全放在包里就行，水甚至都可以带进去。我们在值机的时候，我向 officer 要求 window seat，结果他跟我说没了，并且也把显示器给我看了。我怀疑这些座位都是预先分配好的，也不让我改。过了安检，我点了一杯 KAUAI，我本来是打算喝咖啡的，结果吵那个福州小姐姐的作业就买了一个蓝莓酸奶，不过也挺好喝的，就是有点利好肠胃，导致我后面在飞机上想拉屎。她好像雅思很高分，知道很多我不知道的单词，比如那个拿在手上怕烫的。然后就是和潮阿姨聊天，这阿姨很猛的，好像现在已经玩了六七十个国家了。她问我最喜欢的是那个国家，我寻思我也没去过几个国家。我想了想，觉得日本是最好的，因为很近，很便宜，很方便。</p><p>这个机场登机也是很原始，因为我们需要自己从停机坪上走到飞机旁边再爬上去，然后我们还需要按照规定路线走，走到太靠近飞机会被赶走。然后它上飞机也很友好，可以前后同时上。</p><p>在飞机上，旁边的台州小姐姐和深圳小姐姐在聊天，我后来知道她们好像都是一个人出来玩的，其中台州的和北京潮阿姨一间房，深圳的自己一间房。不过看起来她们比较投缘，在路上一直聊天。我知道台州的喜欢徒步之后，也向她请教了，她从 22 年开始徒步，然后反正很牛逼吧，可能后面要去尼泊尔 ABC。她劝我要从比较简单的路线，比如四姑娘山那种开始。然后她还对我和我老婆的关系进行了一番好奇的询问，比如她就觉得爱情要甜腻腻的，我觉得我结婚更看重关系的对等，女生要有想法。在要着陆的时候，我们看到了很漂亮的落日，以及桌山和信号山以及后面知道的狮头峰。还看到了我觉得是 FALSE bay 的地方，不过因为我坐在走廊位，所以我也不确定。尽管靠着窗子的台州小姐姐把视频慷慨发给我，但是我也看不出来。</p><p>下飞机的时候，好像是要分区下的，五排五排的。我当时没听清楚，就提前帮别人拿包了。不过我本来也不准备走，但是同程的人就很生气，一个白人老太朝我们愤怒挥手。深圳宝妈挺生气，说在欧洲就遇到人特别双标，然后还说为啥欧洲不能兼容说下中文。前者我倒是很同意，后者我觉得就那样。现在英语引导的主流文化就是这样啊，你要融入主流文化，就是得学英语，没啥好说的。但是进一步的，汉语文化应该改造英语，融入中文文化。例如早期的 ketchup、chop chop 以及最近的 niubi 都是很好的例子。如果自己不对主流文化 open，去抢占话语权，反而埋怨主流文化不照顾少数群体，我觉得反而是不自信的象征。</p><p>导游在开普敦机场接机，上了车，这辆车居然有个厕所，但是好像不给我们用，反正我们从来没用过。导游基本上就是介绍了一下开普敦这边的人文和气候，介绍了一下南非的风土人情，这些我们当然都知道了。然后车会路过南非的绿点球场，不过此时黑漆马虎的，啥都看不到。</p><p>晚饭这里，我们还看到了脸一样大的鲍鱼，我还拍了下。回到约堡，在车子上，导游才和我们说这个鲍鱼大概 4000 多兰特，很好吃，算是开普敦必吃的了。这里旁边有桌好像是潮汕的，三个中国人和一个黑人，就着茅台在吃饭，说一堆话，我也记不得是啥了。</p><p>我们晚上又洗了衣服，但是第二天居然干了。感觉开普敦这边湿度看起来 50% 多，但我体感要比约堡干很多，嘴唇也很不舒服。感觉地中海气候并不是很明显，也可能是因为全球变暖，导致这边春夏提前了吧。</p><h1 id="D3-开普半岛"><a href="#D3-开普半岛" class="headerlink" title="D3 开普半岛"></a>D3 开普半岛</h1><p>我们酒店好像住了不少人，好像到七点钟的时候，就有一堆白人学生来吃早饭了。这家酒店的早餐包含了一长排的主食，白人们就会在这里排队，以及那一长排尾部的圆桌，上面放了一些奶酪，水果，三文鱼啥的。三文鱼还挺好吃的，酸溜溜的。这边会有那种鸡蛋饼，就类似昨天那样。不过我去的时候，那边人直接让我拿已经做好的，里面是空的饼，所以我只能自己加点东西，而且是冷的，所以也不好吃。</p><p>今天行程比较赶，所以我们起的很早。早上在宾馆看到了很好看的朝霞，所以我有点后悔昨天没挑选那个 9 楼的。早上在车上，知道昨天一个住 10 楼的女团友（应该是福州的那位）的房门被敲了，而且是反复敲了很多次，然后她很害怕，就和那个福州一人行的大哥换了。</p><p>车开了，我在路上看到一个人在和自己的狗玩，那个狗真的是很活跃，一直在跳。一路上导游问有没有人要观鲸，他推荐不要去，因为很累。果然大家都没去。</p><p>我们第一站是十二门徒峰。一下车我就直奔那个椅子，不过我刚坐下，旁边的小哥就说我坐错了，应该是前面坡下面那个，笑死。不过很多人其实觉得椅子那个打卡的位置不是很好，而是会在下到礁石上拍，我们也在礁石上拍了下。然后，好像旁边几个外国人看到我竖着大拇指还挺神奇的，一直在讨论。我觉得他们应该没有恶意，但其实也有点冒犯。这个海面上飘着很多黑点点，导游说是海带。</p><p>大概在十二门徒峰打卡了半小时，下一站就是海豹岛，它需要我们先走到 Hout bay，然后去码头上坐船。其实我原来对这个行程不是很感兴趣，我觉得就是和洱海的那个游船一样，看看海鸥而已。但实际上这一段还是挺不错的。上船之后，我妈怕晕船，坐在后面，我不怕，所以就坐在前甲板的引擎盖上，不过船一开动，我们就都站来往船头跑了。<br>船上和我在一起的是来自合肥的那个家庭，那一家来了五个人，两个小孩子是在船头的，妈妈也在船头照看。我们聊到在冰岛看鲸鱼的事情，她就说她老公很想去冰岛，我说这里其实比冰岛还远呢。</p><p>首先我们从很像峡湾开口处的地方出来，然后稍微开一会就到了海豹岛。一路上非常冷，我很明智穿了羽绒服。这里的水非常清澈，看着也不深，但我知道这只是折射现象。</p><p>这个时候，我们已经到了海豹岛附近了，船会减速，让我们比较静止地去观察海豹。这里海豹非常多，有的在游泳，有的在礁石上蹲着。此外，还有鸟在石头上。</p><table><thead><tr><th align="center">清澈的海水</th><th align="center">鸟</th></tr></thead><tbody><tr><td align="center"><img src="/img/SA/sw.jpg"></td><td align="center"><img src="/img/SA/eagle.jpg"></td></tr></tbody></table><p>下了船，岸边还有几个非洲人在吹啦弹唱搞气氛，当时已经特别热了。导游好像说这个时候我们可以选择一个 60 刀的无憾小自费，然后可以走一个查什么海边公路，看信号山日落，以及市区的一个什么公园。上车后，他说大家都没选，好像不高兴的样子，但其实也没有人来问我啊。而且我宁愿明天去，因为我想要好望角公园多点时间看。</p><p>反正我们就往北走了一段，导游说这一段是查普曼公路。我其实挺喜欢这一段的，因为我看地图发现这个其实就是早上看的十二门徒峰的背面。</p><p>然后我们就上高速，去吃中饭了。中间有一段上山公路特别好，可以看到开普敦（部分）市区的全景，然后可以看到市区上面飘着一阵薄薄的雾气。一路上导游在和我们讲迪亚士是如何发现好望角的，说他们在海上昏迷了几天，醒来之后，发现海岸线在往东往北移动，从而认为自己已绕过了非洲最南端。</p><table><thead><tr><th align="center">背面</th><th align="center">全景</th></tr></thead><tbody><tr><td align="center"><img src="/img/SA/back.jpg"></td><td align="center"><img src="/img/SA/mist.jpg"></td></tr></tbody></table><p>我们在 fish hoek 的一个叫 robin hood 的中餐馆停下吃饭，这次我们会吃到龙虾。龙虾还是挺好吃的，特别是它的头部，带着虾黄的有一种特殊的鲜腥味。同桌的墨尔本夫妇说没有澳龙好吃。</p><p>吃完饭就出发，餐厅旁边有个教堂还挺漂亮的。中途路过西蒙镇，可以拍到海上有英国的潜艇。这里我们还和火车并行了一段，因为这是早期的通勤铁路，但是现在还在运转。</p><table><thead><tr><th align="center">教堂</th><th align="center">潜艇</th></tr></thead><tbody><tr><td align="center"><img src="/img/SA/back.jpg"></td><td align="center"></td></tr></tbody></table><p>下面一个景点是企鹅滩，进门的时候我就看到它复杂的门票收费牌子，这个后面在植物园我详细研究了下，这里就不展开了。进口有厕所，然后出口在旁边，经典的是穿过一条购物街再出去这样。这个企鹅滩主要分为两条路，一条路最终通往海滩的左边的一个木栈台，而另一条路就是通往右边的木栈台了，两个木栈台是可以互相看到的。不过很奇怪的是，左边这个木栈台上的人特别多，基本上都不太能挤到栏杆边上，但是右边那个的人就很少。</p><p>我们看了会，就去右边那个栈台，基本就是折回到出口，再走另外一条路了。这条路是在里面的，所以看不到海。不过则可以看到小企鹅，以及企鹅的巢穴。</p><p>我们在右边栈台看了会，就回去了，我妈是提前回去的，因为她担心赶不上。我稍晚点回去，路上我近距离看到了一个小企鹅。在 13.06 的时候，我们还看到了两个企鹅在吵架。</p><table><thead><tr><th align="center">小企鹅，感觉眼睛像画上去一样的</th><th align="center">企鹅吵架视频</th></tr></thead><tbody><tr><td align="center"><img src="/img/SA/qie.jpg"></td><td align="center">待剪辑</td></tr></tbody></table><p>在某个时候，车子突然慢了下来，原来是看到了狒狒。再往前，车子会往左转弯，然后开过一个收费大门，我们就正式走到景区里面了。这后面的路就不像之前在悬崖的左边走了，我们会横着走一段路，然后在半岛的右边继续往南走。</p><table><thead><tr><th align="center">悬崖边的狒狒</th><th align="center">好望角地形</th></tr></thead><tbody><tr><td align="center"><img src="/img/SA/hwjff.jpg"></td><td align="center"><img src="/img/SA/hwjdx.jpg"></td></tr></tbody></table><p>快到好望角的时候，我们还看到了鸵鸟，可惜我没拍下来。我们先去的是海边的好望角，那边其实就是一个木头牌子合照，需要排队，但因为是淡季，所以基本没啥人。左边有另一个牌子，是 scenic walk，往前走就是那个有名的徒步步道，可以一直走到迪亚士海滩，然后再到开普角。不过导游一开始就说千万不要走那条道。拍完之后，我们往海面走，不过因为全是礁石，我们只拍了一会照片。后面在回深圳的飞机上，听到邻座的人说实际上是可以走到海边玩玩的。海上远远的有很多轮船，然后又非常多的海鸟飞过。在好望角我发了个定位，距离南京 12813 km，应该是我现在到过最远的地方了。</p><p>我们在好望角呆了不长时间，我觉得如果自由行的话，完全可以在这里多待一会，吹吹海风，看看海鸥，然后从这里开始一场去往开普点的徒步。但是我们是坐车去了开普角，从这里我们可以往上小爬一段路，目标是灯塔。一路上我们都可以看到迪亚士海滩，和好望角的背面。灯塔这边是我们的终点，它算是一个制高点。灯塔上有景点的方向牌，显示我们这边离南极只有 6000 多 km。这里的好处是，不仅可以看到好望角和迪亚士海滩的方向，还可以看到开普角，以及北边，算是 360 度的视角，其中有 270 度都是海景。</p><table><thead><tr><th align="center">开普点看好望角</th><th align="center">开普角</th></tr></thead><tbody><tr><td align="center"><img src="/img/SA/kpj.jpg"></td><td align="center"><img src="/img/SA/kpj2.jpg"></td></tr></tbody></table><p>在这里，我们和北京潮阿姨组队，互相拍了很多照片。潮阿姨也聊了她去玩过的很多地方，我问她你觉得好望角是第一梯队的么，她说那肯定的啊。她说后面他还想去南美，说今年12月份已经交了个定金，在犹豫要不要真的去。她还说他儿子啥都省，但是就是出去旅游不会省。我觉得好望角确实很漂亮，因为虽然有很多有历史意义的地方都被做成了景点，但是其中少有是真的漂亮的，但是好望角并不属于这一类。</p><p>回程的路上，我们发现中途一个上厕所的地方居然是一个缆车站，也就是说如果不想爬这个灯塔，也还是可以坐缆车的。这个缆车站不仅有厕所，还有一些陈列着的文物。我们在上厕所的时候，看到两个外国人应该是准备乘缆车，往里面走来。</p><p>本来我以为我们会选择要不要坐直升机的，我还在上海豹岛的时候和别人讨论了下。结果导游都没有提，我们大概下午三点四十的样子就往回赶了。回到了市区，我又看到了桌山。</p><p>傍晚，我们在 Timeout market 闲逛，里面东西挺贵的，我们团也没有人买东西。从 market 穿过，是人比较多的一条酒吧街，再往前走，穿过一座桥，是一个很漂亮的灯塔。我们走到灯塔发现很难再绕回来，就走了回头路。然后发现导游和一些人在酒吧街坐下吃东西，但是我们选择去拍桌山，因为这个时间的桌山在码头拍很漂亮。然后我们又往另一个方向走，走到灯塔对面我们之前绕不过去的位置，发现那个是个可以升起来的铁桥。Timeout Market 是一个很适合落日时间拍桌山的地方。</p><p>晚饭吃的中式鸵鸟餐，鸵鸟肉好像是羊肉，也没啥特别的。如果他不说，那么我们都不知道这个是鸵鸟肉。</p><h1 id="D4-开普敦"><a href="#D4-开普敦" class="headerlink" title="D4 开普敦"></a>D4 开普敦</h1><p>早上先去酒庄，导游给我们介绍酒。第一个是白葡萄酒叫 Sauvignon Blanc，酸。后面几个是红酒，分别是 Merlot、Shiraz、Pinotage 和 Gouverneurs Reserve。然后导游就说他卖酒，说南非这边进货价最多 50 rmb，运到中国就成本就得 90+ 了，然后再卖给一级经销商 100+，二级经销商就得 150 左右了。完了他说走他那里买只要 120，要买的加他微信，好像就一个人加了，感觉那导游也不高兴。就我觉得导游在南非过得好像人有点轴了，你说了一级经销商才 100+，不是明着说至少多赚我们三十块钱嘛。</p><p>我们从酒庄就直接去植物园了，在植物园门口可以看到它复杂的门票计价，分为老人、0-5岁、6-17岁、SA 大学生证、非洲人、SA/SADC 公民，以及什么都不是的人，价格分为免费、40/60/110/150/270，可以说非常悬殊。进去植物园之后，导游就和我们说从右边一条路走，然后走到头往左转就可以回来到这里曼德拉头像的出口，不要从另一边直接出去。然后在某个地方山上走可以看到一个网红的桥，我们可以爬山去的还是推荐去看下的，然后就解散了。</p><p>我首先带我妈走右边的路线，理论上我们走一圈就可以回来了。一路上我们看到了不少植物，例如黄色的天堂鸟。然后还有经典的芳香植物（一点不香）以及要灭绝了的植物（都是绿的）。中途我看到一个 forest path，它也是往山上走的，正好和导游说的一样，我就以为桥在那里面，但是我妈很害怕，无论如何，我们还是走了这条路。出来之后，很快我们在一个大草坪上碰到了我们团队的其他人，这个大草坪中间还有一汪水潭，时而不时的有鸟飞过，非常漂亮。因为这个草坪需要往下走，我妈就没有下去，跟着北京潮阿姨在聊天。我绕回去找到她的时候，她又很生气了。</p><p>不过我们很快就找到了墨尔本的夫妇，因为他们已经走到头了，准备回头逛逛，找那个桥。所以就和他们一起走了，我们从一个 Dell &amp; Bath 的地方往前走，走到两棵树，好像也有一百多年的树龄了吧。我说我往前看看，然后在往上爬，会到了高处，那边有几株植物很香。这边大概是一个弧形的路在高处，我们上来的地方形成一个三岔口，往下看，还是蛮好看的。这个时候，我妈和墨尔本夫妇也跟了上来。大家对导游意见比较大，觉得你也不给我们指路怎么走。我于是就打算往回走了，但这个时候前面走来一个外国人，我问他知不知道那个 famous bridge 在哪里，他说是不是在找 canopy 啥的，我也不知道这个 tree canopy 是啥，不过他说就在前面，并且 not far，他们已经去过了。但是他没说到底是前面哪条路，于是我走了最右边的一条路，然后它把我导到了更高的地方，不过那地方很漂亮，是一些绿色的草甸，还能看到远处薄雾下的城市，我在那里拍了一些照片。然后我也准备回去了，不过路上，我又看到很多人过来了，我想一定不远了，所以我又问了下，这次那边人和我说，就是某条路，这个时候墨尔本爷叔忍不住了，就往前走，果然立刻就看到了。我本来以为这个桥是个什么架在峡谷上的桥的，结果它就是在树荫间盘悬着的桥，难怪 tree capony。回来的时候，终于看到 tree canopy 的牌子了。</p><table><thead><tr><th align="center">路牌</th><th align="center">桥</th><th align="center">黄色天堂鸟</th></tr></thead><tbody><tr><td align="center"><img src="/img/SA/canopy.jpg"></td><td align="center"><img src="/img/SA/qiao.jpg"></td><td align="center"><img src="/img/SA/ttl.jpg"></td></tr></tbody></table><p>我们觉得我们估计是唯一找到桥的，结果喝茶的时候好像台州-深圳组合也找到了。反正大家又是一路吐槽导游，还想卖酒呢，我说他要是卖酒生意这么好，还来干什么导游嘛，大家都觉得很有道理。我们算是压点到了，结果头像那边也没人，我们在群里问了才知道他们已经出去等茶喝了，所以我们就出去。给了一杯茶，就那样，给了个吃的，巨甜无比，不好吃。</p><p>然后出发去 Truth coffee，路上遇到一堆红色建筑，还有一个很大的操场，里面有人在跑步，这个是开普敦大学，我们来的时候导游介绍的，不过当时在右边出现，我没看到。导游说说是第一例心脏移植手术就是在这个大学做的。后面我还看到一个城堡，原来叫好望堡。</p><p>这个咖啡店是在红灯区，旁边的店面就是一个裸女。这家店好像要等位，我们等了好久。中间我去买了个咖啡豆。这家店的菜单很有意思，像个报纸一样。店面是蒸汽朋克风格的。</p><p>过了会，我们终于坐进去了。这个咖啡感觉也没啥特别的，但是服务小哥很帅。然后一个卡位只能坐 6 个人，但是他们没地方放东西，就往我们桌子上放了有额外6杯多咖啡。我们吃的是三明治，一个人两片，意外很好吃，不过分量也很大，我妈吃了 1 片，北京潮阿姨吃了 1 片，大家都要我带走，不过我感觉冷了不好吃了，就带了我妈的那片。</p><table><thead><tr><th align="center">咖啡</th><th align="center">三明治</th><th align="center">充满情绪价值的糖</th></tr></thead><tbody><tr><td align="center"><img src="/img/SA/kafei.jpg"></td><td align="center"><img src="/img/SA/smz.jpg"></td><td align="center"><img src="/img/SA/tang.png"></td></tr></tbody></table><p>喝完咖啡，我们在路边闲聊。路边有个像是公交车一样的亭子，可以坐在里面喝咖啡或者拍照。福州阿姨知道我准备去 minimax 还挺好奇的，因为她知道这家公司。墨尔本夫妇知道之后，也鼓励我继续干下去，欢迎去澳洲。</p><p>说到一半，好像一个面色焦急的白人妇女跑过去了，后面跟着两个警察。本来我们以为遇到了真实的抢劫，后面看到两个带着摄像机的人，原来是拍视频啊。</p><p>然后就是去信号山，它可以直接开上去。我们车到的时候，正好有一个人在准备玩滑翔伞，我们等了一会，他还是不动，说是没有风，于是我就走了，再过去的时候人已经没了，听别人说因为等了好久没风，就把伞收起来走了。然后我们就下来绕着信号山走，首先是先去海的那边看，可以看到绿点球场，已经关押曼德拉的那个小岛。在信号山面向桌山的那边，离开主路，有一个小黑哥坐在山体外缘的一个石头上，旁边放着几罐红牛，他就那么坐着，看着桌山。我上去搭讪，说他找了个好位置，他说是的。他说他是本地人，在这边工作。我欢迎他来中国，他说这边签证太贵了。</p><p>然后我又带着我妈往海的另一个方向逛，这边路不是很好走，有一堆草。不过那边可以看到开普敦城市的另一部分，我妈和我爸打了视频电话。走了一会，我就往上走绕回主路，然后再穿过主路往桌山方向走，就是另外一个拍摄桌山的好地方。然后我妈去上厕所了，我就沿着上来的盘山公路往回走了点，这样可以拍到更好的绿点球场。</p><p>逛完之后，我妈已经和北京潮阿姨坐在一起了，旁边是好多黑人。潮阿姨还问了一个黑妹辫子是怎么弄的，她说是接的。潮阿姨叫我去 social 下，我简单聊了下，他们是本地人，他们没有爬过桌山。他们问我是从哪里来，我说从中国来，不过他们好像都没有去过中国。他们问我们去哪里，我说 pretoria，johannesberg，cape town，最后会去 port Elizabeth。其实我想说花园大道，但是我不知道怎么说，不过他们也懂了，说那边很漂亮。他们也对中国比较好奇，问了我一些中国的城市，最后，他们问我上海人是不是都信仰佛教，我说有一些，但也有信仰耶稣和安拉的。信号山比较安全，因为上面有很多持枪的警卫，我上去 social 了下。其中一个戴口罩的警卫很 nice，他说他们不能露脸，所以只能他和我合照，另外一个警卫只能在相机之外。我刚合照完，一个后来知道是从泰国过来，马上还要去英国的纯自由行老哥就来也想合照一张。这个老哥是湖南人，但是说话一股港台风。后来我们简单聊了下，他常驻泰国，在泰国也有房子，所以过来方便。后面深圳宝妈也和他聊了下，还加了朋友圈。据说他在比勒陀利亚还遛过狮子，好像原价 2500 人民币还是兰特，他也不懂英语，但就靠翻译器，把价格砍倒了 1000+。他说遛的时候，旁边都有人用枪指着狮子的，如果狮子不轨，就会立刻杀掉。</p><p>从信号山下来，去了马来区。这边没啥意思，就是红红绿绿的房子，我们在新加坡看多了。大家也没走一会就回去了。我们和潮阿姨聊天，吐槽北京很魔怔。阿姨说自己幸亏没住在城里面，天安门那边烦的要死。说北京不让飞无人机了，他儿子很不高兴。说自己住在鼓楼那边，但也觉得很不舒服。北京挺好玩的，可惜是首都之类的。马来区感觉也有一些流浪汉，我提醒大家要注意点口袋。</p><p>晚饭是英式鱼排餐，我们在一个叫 somerset 的商场里面，我想到我们之前就住在新加坡这个同名的地方。我先去买了个 lip protector，他们听不懂，我就说 vaseline，他懂了。然后我临时搜小红书在商场买了个 savanna 酒，不过是啤酒口，我开不了。然后我问导游，导游说鱼排馆里面不能自带酒水的。不过福州阿姨慷慨给我分了点他们买的啤酒，于是我们也喝上了。这个虽然是英国的国菜，但还是不错的，烤的也很嫩。我的鱼有鱼刺，但是我妈的就没有。</p><p>吃完饭，我们就到宾馆，这是一个庄园式的宾馆，我们的房间在二楼，但是没有电梯。到了宾馆房间，我发现房号给错了，我们的居然是个大床房，原来是向导的问题，我们和旁边的深圳宝妈换了房间。墨迹完，我赶快出门，拍到了晚霞。晚上我还和我妈发生了争吵。</p><h1 id="D5-摩梭湾"><a href="#D5-摩梭湾" class="headerlink" title="D5 摩梭湾"></a>D5 摩梭湾</h1><p>早上起来，在酒店闲逛。这个酒店左右两边有两个游泳池。然后这个庄园的客房是两排，每一排都非常长，并且一排高一排低，在一个山坡上。</p><p>今天从酒店出发，一路往东开，开到乔治，路上只有一个景点迪亚士博物馆。上车的时候我问了下向导，今天是不是有自费，向导说要我问导游。导游说帮我问下，但是基本上大家都不会去。结果当导游说要多 2h 的车程的时候，就我们投了去玩的票。这个景点我还是挺想去的，因为这个是真的非洲大陆的最南端，两洋交界处。导游的意思是说那边也看不到两洋颜色不一样，其实我在回深圳的飞机上听中间位置的小姐姐说才知道，看两洋分界线的位置就在 FALSE bay 那里，我们可能在车上都已经经过了。</p><p>我们半路上了个服务区，在那里，导游给我们发了午餐。一瓶可乐，和一种里面是芝士肉糜的三明治。这个东西还挺有特色的，饼感觉类似面包，表面有很多白屑。那为啥我叫它饼呢？因为它没有面包那么蓬松，感觉很扎实（实际上也很扎实），吃在嘴里也很筋道。馅料，芝士是偏酸的，肉糜比较碎。口感反正酸酸甜甜的，挺有趣的。</p><p>整个花园大道，在八月初其实就只能看到大片的油菜花，时而不时的，我们可以看到一些其他的花点缀其中，但还是以荒草为主。兴义有个万峰林景区，有很多锥子山以及油菜花海。这里的山间的花海也有点这种感觉，当然没有那种喀斯特地貌。值得一提的是，虽然是地中海气候，但是这边“稀树草原”的稀树特点确实体现很明显，一路上我拍到了很多形单影只的树，感觉挺漂亮的。</p><p>导游在过程中给我们讲了下南非这边的福利保障制度。比如作为最下层住在贫民窟里面的人，他们的住房实际上是免费的，并且水电也是类似于印度那样直接白嫖的。南非有一个最低保障金，只要没有财产和收入，就都可以领，大概有个几千兰特，很多人就靠这个活着。然后，他们会游荡在城市中，成为流浪汉，捡垃圾，偷窃或者抢劫等。</p><p>今天唯一的景点就是半路上的摩梭湾那边的迪亚士博物馆。到了博物馆，我们先要在门厅听那个导游的集中讲解，导游就那个花园大道的地图讲了半天花园大道的各个城市可以做啥。然后介绍了齐齐卡马国家公园，意思就是说这个自费可以去。我本来就想去，虽然我知道这些自费项目价格都挺不合理的。</p><p>然后，我们就穿过门厅，到庭院里面，这里有个日晷，可以看时间，我们试了下还挺准的。另一边有一个邮政树，树旁边有一个鞋子样式的邮箱，可以拍照。</p><p>在往前走，正面是摩梭湾的海滩，右边就是迪亚士博物馆了。这个博物馆里面有一个大船，是多少周年的时候葡萄牙送给南非的，从 24 年开始已经不让上去了，但是很大，我们在这拍了照片。导游在这里进行了一番很中国的讲解，扯了一堆简单的四大航海家，以及郑和啥的，我都没有听，去逛了一下。其实这个博物馆除了航海之外还有很多别的东西，叫他历史馆会更好。比如在一楼就展示了这边的人类的化石，据说是 16000 年之前的。还有很多有关一个岩洞的图，这个应该就是我们没有去的那个自费项目中包含的另一个科萨人岩洞了。另外，这边还有一些和一个沙滩上的柱子有关的图片，这个好像是一个很有名的历史景点，不过应该不在这个博物馆里面。然后后面还有一堆我已经知道的历史，比如 San 人啥的，班图人啥的，以及后面葡萄牙人和英国人来的历史。二楼上去是近代史有关的陈列，里面放了一些打印机、电话机、缝纫机、牙医的床什么东西，比较有年代感。</p><p>我们也下到海滩过去看了下，看门大妈直接放行。不过海滩也没啥意思，台州深圳组合爬下去了，我们走了。这个里面还有个贝壳博物馆，里面好多贝壳，还有鲸鱼的骨骼。大部分贝壳和我看到的一样，但是有一些还是挺别致的。比如有一个好像是站着举着盾牌的人。另外，我还看到一个叫 mud skipper 的鱼，我妈说她路过的时候，这个鱼往前窜了一下。</p><p>到了酒店，这也是个庄园式的酒店，叫什么 Protea 的。我们在植物园的地图上看到很多 Protea 的园子，我知道是南非的一种特色的花，不过具体是啥我也不知道。导游说晚上五点半来拿晚餐，是 KFC，就走了，让我们自由活动。我们先回到房间，这个房间还是不错的，有个阳台，不过隐私性不太好，隔壁的墨尔本夫妇在阳台上的动静都能听到。我们就酒店转了转，这个酒店也不是很大，基本上就是穿过前台一个泳池，然后泳池边可以坐着晒太阳。而前台的另一边就是一个大院子，我们就住在院子里。院子里面也有一个泳池，对着我们的阳台，不过是关着的。</p><p>我下午就在前台这边的草地上躺在椅子上晒太阳，喝着在商场买的 savanna 酒，它还挺好喝的一种水果啤酒吧。我就着免费爆米花喝完了，然后酒店前台还有个很好喝的水，酸酸甜甜的，我去喝了很多。一开始我想着在游泳池里面游会泳，一摸水，真的是冷的不行，于是放弃了。</p><p>这个酒店的 wifi 很扯淡，连进去之后，有三个选项：guest、conference 和 complimentary。我们聚拢在前台，那边马达母教我们直接连 complimentary，不过要每四个小时重新连一下。导游也在那边解释，反正意思是你们拿饭的时候来重弄下就行。结果吃饭的时候我过去，发现无论我如何 forget network，都没法再重新弹出那个页面了。马达母拿着我手机摆弄了半天，叫我输入一堆网址，也没有用。结果我就拍了一下她的操作，然后把客人清单发了一下，这样我可以根据 room number 和实际住的人的姓来用 guest 网络，省得麻烦。最后确实是过了四个小时之后的晚上，我才重新连上了 guest。另外我晚上漫步酒店的时候还看到 conference 的密码，也分享给了福州的两个大哥，不过他们说好像连不上。</p><p>晚饭是 KFC，分量很大。汉堡很大，薯条一般，但是很粗，有给了番茄酱和特别的 chili，还有个原味鸡和土豆泥。我妈连中午的那个芝士汉堡都没吃完，KFC 也是只吃了个原味鸡，她说不喜欢吃土豆泥。</p><table><thead><tr><th align="center">芝士面包</th><th align="center">KFC</th></tr></thead><tbody><tr><td align="center"><img src="/img/SA/zhishi.png"></td><td align="center"><img src="/img/SA/kfc1.jpg"></td></tr></tbody></table><p>晚上散步，这个宾馆还有一个台球房，里面还有一些电玩机，不过现在里面是空无一人。我们遇到了墨尔本来的夫妇，聊到下午都没几个人投票去齐齐卡马，大家意思都是说这个导游不会赚钱，90 刀太贵了，其实他要 60 刀，大家都会过去，他反而能赚更多，他这样就是双输。我就说我现在知道路线了，下次来南非直接自驾，我还说我后面想去澳洲自驾，就劝我不要这样，因为澳洲和南非一样是右舵，容易出事。他说他有个认识的人就是来珀斯自驾，然后就撞死了。我们还交流了团费，他们好像就是 21999 + 1200 原价买的，我也没好意思说我们的价格。</p><p>这个酒店其实也挺破的，比如我们洗澡的时候，莲蓬头居然往上滋水，导致我洗了一半发现天花板上在淌水，我以为是天花板漏了。</p><h1 id="D5-奈斯那"><a href="#D5-奈斯那" class="headerlink" title="D5 奈斯那"></a>D5 奈斯那</h1><p>今天唯一的行程就是奈斯那游船。尽管如此，我们还是早上八点半就起来往奈斯那开了，估计是因为船票是固定时间的。从乔治往奈斯那开也是有点时间的，中途我们会经过一个叫 wilderness 的地方，是一个挺长的沙滩，有很漂亮的海浪。</p><p>上船前需要给我们每个人都套上一个黄色的手环。这个船上有不少外国人，我们开起来之后，就是英文讲解。主要是讲解这个湖上的两个小岛，说在上面买房究竟有多贵。然后还介绍了一下这个湖。突然，有一个 guide 说有一个海豹游过，大家的照相机立马就全部举起来了。外国人在中途一个地方登陆之后，船上瞬间就剩下我们团队和另一个中国团队了。我让向导去问下 guide 我们能不能上去，答复是不能。然后船就开动了，guide 用中文说了很长一段的欢迎词。</p><p>拍完照片，我就去和 guide 聊天了。原来他叫 johnny，我夸他中文很好，问他是如何学的。他说就是用 google 翻译器学（感觉和潮阿姨一样），有的时候，他也看 youtube。他和我说，google 翻译器可以告诉他中文怎么读。我问他能不能认识 chinese characters，他说不会，但是能看懂拼音（他说的是）我问他有没有用过 duolingo，他说那个不好，因为他需要知道如何对话，duolingo 教不了这个东西。他说他会中文，还会德语，然后我们一起说了 Guten Morgen，他很惊讶，我说我还会法语，他和我 Bonjour，我 enchanté，然后我们又法语简单聊了几句，然后他就开始讲一些我听不懂的了，我及时打住。然后我就问他你知不知道中文如何说 awesome，他说不知道。我就说跟我念，niubi，他就跟我念了，我们还拍了视频。过了会，他又主动过来找我，原来他在 youtube 上搜到一个中文博主讲 niubi。说 incredible、awesome 这些词都可以说是 niubi。我说 yes, chinese is quite easy, everthing is niubi, niubi for everthing. 随后，我又问了一些这边的问题，比如他说我们的船是没法从奈斯那岬角下去的，但是更大的船是可以的。我问是不是因为有落差，他说是的，大概有 2m，我很怀疑真的有这么高么还是我听错了。我问为啥我看不到更大的船，他说这些船一般是运木头的，并且一般是出去而不是进来，这个季节是没有的。我说是不是春天和秋天比较多，他说是的。然后他说你们从这边出去就可以到中国，我问他你去过么，结果他同样也没去过中国。我说我很喜欢他的工作，他说是的，他每天可以看到很多人。每天都有中国旅行团过来，说到这里，他很着重的说了 everyday。我说 so you are a language genius! 他听了很自豪，说 yes I am. 这个时候我感觉我和他形成了共鸣，因为我也喜欢夸赞和自夸，并且认为谦虚并不体现在外在。</p><p>说这个船是一个半小时，但我们实际也就开了一个小时左右。下了船，我们在岸边稍微走了下，路过还是一个 Protea 酒店，然后就过马路到镇子里面。我们在一家中餐馆吃了午饭，中间墨尔本的大叔就说南美很好玩，说他和老婆两个人过去，是找的 1v1 的向导，相当于去哪里是自己定，向导负责安排，就很舒服。然后大家还交流了报团多少钱。台州姐姐知道我 1200 的服务费全退了就很生气，因为她只退了 1100，然后就要我的真名，说要找她的地接社理论，导致我都不敢告诉任何人我实际花了多少钱。而且我觉得拿我的 case 去和别人理论这个事情也不太好，桌上其他的人也劝她别这么干。</p><p>吃完饭导游就让我们四处走走。我们和潮阿姨边走边聊天。我们走过的地方，是奈斯那湖畔的小广场，这边虽然有点破旧，但是人很多。阿姨也感叹去的青岛那些地方这些商场都开不起来，为啥这边人能这么多。我们在旁边一家商铺的裸女（只有阿姨拍了）和长颈鹿雕塑旁边拍了照片。从商场出去是湖的沿岸，没啥东西，主要都是船库。我们走的时候，就有一辆车拖着游艇过去，那游艇还挺大的，其实我们在路上也经常看到车拖着游艇走。她说她丈夫就喜欢在家鼓捣做饭，不喜欢出去玩。说他丈夫退休工资高，说是一个技术兵种退休的，在海军上研发设备。说退休的时候是军级干部了，不过是技术性质的。说那一代人确实工作有自豪感，生活条件很差。我说现在军工不行了，我们现在都不去了。她说她都懂，各种腐败或者外包啥的问题。我说最重要的还是军工太封闭了，我们做 ai 需要的是全球化竞争。阿姨还给我展示了她的 pixel 手机，她说她是 google 粉，有 google 全家桶，还把华为贬低一番。我虽然支持华为是垃圾，但是我觉得 google 也没有宣传中那么有道德。但是我也说了，其实近几年计算机和 ai 方面的更新，很大程度上都是 google 引领的。</p><p>刚才往南逛完一圈回来，感觉这边开车都很文明，基本上没有红绿灯的地方都会主动让你走，我反而有点别扭，都挥手让开车的先走。然后我们就打算往北走走，然后稍微走了一个街区，就感觉很多黑人流浪的在走，有一个走的歪歪扭扭的，我怀疑都是吸了毒或者喝了酒的，我就等他先走。后面遇到了墨尔本来的夫妇，我们就和男的一起走到附近的 tourism centre 去看看。本来以为是一个像挪威那样挺大的集散地，结果就是个带铁门的房子，里面像酒店一样的前台，坐了一排员工，看到我们眼睛都没抬起，我们就自己看了下。</p><p>回到酒店，我先在前台那边的休息区看了会书，这是个叫 READER’S DIGEST SOUTHERN AFRICA 的很大很重的书，看起来他是 199x 出版的，因为它很多数据知道 1992 年，并且里面的 DRC 还在叫扎伊尔呢。不过这本书还是挺有意思的，不仅讲了南非的地理，还讲了南非的历史。</p><p><img src="/img/SA/book1.jpg"></p><p>当我以为这本书就是个科普的时候，我发现它后面有超级多和详细的南非各个尺寸的地图，另外还包含了纳米比亚和莫桑比克的地图，所以是真神奇。我看了一点，然后就发现深圳和台州小姐姐在外面晒太阳，于是我也打算出去。确实下午的太阳很舒服，我喝着酒店的免费饮料和免费爆米花，然后和我老婆聊了会天，她那边都要睡觉了。</p><p>晚饭还是五点半，是叫啥 SPUR 的猪排堡，配有洋葱圈和薯条，另外给了芝士酱。这个 SPUR 应该也是个什么有名的品牌，那里都能见到。我妈还在酒店拿了南非苹果，这是因为之前在盒马也看过南非苹果，觉得很神奇。南非苹果还是不错的，比较偏干一点，但是很酸甜。猪排堡很大很好吃，大部分味道都来自里面的酸黄瓜和西红柿。洋葱圈和薯条都已经被水烂掉了。</p><p>当然，在吃饭前我们还是先去看了落日。今天的晚霞特别美，我拍了很多照片，发给鑫鑫看。他觉得旅行也不错，我们也计划国庆节一起出去玩一下。回来之后，我又试了下望远镜，感觉确实效果不错。然后我就看着楼下的黑人保安在盯着我，不知道是好奇，还是因为我在拿着枪而警惕。</p><h1 id="D6-乔治-克鲁格"><a href="#D6-乔治-克鲁格" class="headerlink" title="D6 乔治-克鲁格"></a>D6 乔治-克鲁格</h1><p>今天早上就要出发去乔治机场，果然在 checkin 工作人员和我说没有 window 了，但是我妈却拿到了 window。因为我妈不拍照片，所以我就坐在那里了。这个机场比比勒陀利亚的那个更小，只有一个等待大厅。然后二楼是 longe。厕所也很少，我最后去二楼上了下。我们等的时候在那里聊天，潮阿姨聊他儿子也不喜欢体制内。原先她帮忙找了工作，然后他又不喜欢，结果又重新找了一遍，现在也不喜欢，但是只能这么干着。我说体制内也不是很好，年轻的自由很重要。我后面还说了我景点的理论，世界在变，如果人不跟着变，那么生活质量就会变差。完了，阿姨还说他儿媳要去加拿大生小孩了，说很金贵，得五十多万，我说五十多万买个选择并不差。</p><p>阿姨还给我展示了她的 Google 足迹，她让 Google 总结去了哪些国家，Google 就总结了，真的有 61 个，不过也包含了香港这种。还有个巴西她实际没去，也不知道为啥加上去了。</p><p>在飞机上我、我妈和潮阿姨坐在了一起，我妈在中间。在飞机上，我能看到在快速消失的海岸，以及靠近海隆起的山脊。前一段的路程地貌非常皱褶，很快，眼前的绿色就消失了，换成一开始看到的黄草和黄灰色土地，我觉得黄草有点像冰岛的一部分，但冰岛的草没有那么高。然后，皱褶就消失了，应该变成了高远，但还是能看到一些河流和湖泊的。</p><p>到了约堡机场，向导开始发饭，潮阿姨觉得很不高兴，因为没问她要不要。我倒是知道向导在乔治机场点饭的，他也确实是给自己点的，只是被别人看到了，要帮忙带。但是我觉得在外面吃啥中餐，而且也不好吃啊。我和潮阿姨在约堡机场二楼逛了逛，她买了个什么卷饼一样的，我买了个叫 bobotie filled 的三角，实际上里面是加了香料的肉，吃起来还不错。</p><table><thead><tr><th align="center">bobotie filled</th><th align="center">机场植发广告</th></tr></thead><tbody><tr><td align="center"><img src="/img/SA/chide.jpg"></td><td align="center"><img src="/img/SA/zfgg.jpg"></td></tr></tbody></table><p>出了机场就上车，去克鲁格。这次这个车换了，比较烂，行李要放在车的后面，并且上下车的台阶也窄了很多，座位也少了很多，车还没有窗帘，很晒。</p><p>约堡的导游，我之前一直吐槽他耳朵不是很好，我问问题他老听不到，但是在经过了开普敦之后，我觉得他还是不错的，至少他能讲不少东西。比如刚走不久，导游就指着右边远处的白色的像小山一样的东西说这个实际上是当时约堡大炼黄金之后剩下的土。我坐在左边，也没有拍到，只是看了一眼。</p><p>我们中途停在了 Entokozweni 附近的加油站，这好像也是个什么景点，有个黄色的相框。然后有个小卖部，我进去看到了一个 miracle balm，好像是唇膏。我本来想买的，但是又怕那里不正规。上车之后，导游说这边其实可以随便买，说南非人还没有聪明到这个程度。然后他又说这条路线上有个橘子店，他很喜欢去那边买橘子，所以大家都叫他 mr orange，然后他又说了下南非的很多水果，比如他们还有蓝莓啥的，基本上是每个季节有不同的水果。</p><p>导游先讲了点开普敦那边的吃的，比如那边有个龙虾小镇，龙虾很好吃，不过那边不能把龙虾带出小镇，所以他们就会开三辆车过去，走的时候找一个人打头阵，看看有没有警察查，如果有警察查，也可以拖着警察，掩护后面的人撤。接着，导游又和我们讲南非的玩的。比如这边有很多房车基地，不过最刺激的还是 safari。然后他说还有一种特色的打猎，就是专门的一块地方，进去之后你选择用弓箭或者弩箭或者手枪等武器，然后会有专门的猎人带着你逛，看到一个动物，猎人就问你要不要，你要的话，就报价。一般一个羚羊几千，一个斑马两万，一个狮子根据公母分别是 20w 和 10w 左右，一个大象是 70w，都是兰特。因为大象很猛，所以打的时候都会有七八个人帮忙介错。另外因为犀牛很少，所以都是全球竞拍，拍到的人会在动保组织的监视下打猎。然后误杀也要给钱，比如有个比如想打羚羊的，结果打了狮子，就得按照狮子的钱给。然后打到的会做成肉干，头会做成雕像送给国内，保证能过海关。</p><p>一路上能看到很多大卡车，感觉他们是在挖矿。然后走到 Mbombela 这个城市之后就下了高速。然后，我们就在城市里面绕了一圈，我看到了长安和比亚迪的 4s 店。然后这个城市有公交站台，很大，像一个棚子一样，然后公交车也是很长的那种。应该刚好是下班高峰期，所以很多黑人在等公交车。我们实际上要往 White River 那边走，走了一段，台州姐姐要上厕所，所以我们停在一个服务区，出来的时候，闻到很浓的秸秆味道，我还拍了下落日，还不错。</p><p>然后越走天就越黑，路上随机刷新黑哥哥们。这边好像就比较乱了，因为房子越来越差，并且很多小卖店都是带着铁丝网，买东西好像在银行里面取钱一样。但是这个地方好像也很友善，虽然没有路灯，但是每一家门口都会点一个白色的灯。我们走过 Phola 之后，就要往右拐，这个时候我们可以看到远处的山头上的点点灯光，很漂亮。另外，那些公交车和公交站台一直伴随着我们，哪怕我们一路上经过的地方是越来越破的。</p><p>我们的终点是 numbi gate，到的时候门是关的。导游很生气，因为他说的是我们在 18.30 左右到，但是那边的意思是你到之前 10 分钟告诉他们。导游觉得我都说了 18.30 左右到，那意思不就很明白了嘛。然后导游和我们说，这个门 18.00 之后就不给开了，因为里面就是野生动物保护区了，他们怕我们和野生动物互相影响，所以要开车引导我们进去。所以等了 10 分钟，他们终于开车来接我们了。这个时候，合肥的老爷爷问能不能不去，看起来他好像身体不太舒服，向导说可以，但是不会退钱。</p><p>晚上到了帐篷酒店，服务人员会帮我们拿行李，他们确实应该这么做，因为我们的帐篷，比如我是 50 号，离前台非常远。其他人的就更远了，有的人是 59 号，基本上已经到了边缘了。我们晚上吃的是篝火晚宴加上烛光大餐，看上去很浪漫，但实际上又冷又看不清。这边很多吃的也是冷的，但是有牛排和烤鸡。我吃了三块牛排和烤鸡，感觉还不错。但是牛排感觉烤的很老，所以不太嚼得动。然后外面又有酱汁，所以第一口感觉就是纯在吃酱汁了，很咸。然后这边没有水可以喝，我想点啤酒，但是又觉得很冷，问了下，热的只有茶，算了就不想喝了。</p><p>回去帐篷酒店，这个酒店进门之后需要用钥匙反锁，我妈一进去就要我反锁，我觉得很麻烦。这个帐篷通过魔术贴实现了建议的窗子的功能，其中顶上还有几个，我以为可以拉开来看星星，结果发现撕开也还是那种蚊帐的构造。过了会，我发现贼冷，于是又得站在床上，把这几个魔术贴重新加固一下。</p><p>开空调到 28 度，这个空调感觉很差劲，很吵。我们开着 28 度，我带着耳塞睡觉。结果躺着没一会，就有人来敲门了。他和我们用英文说这个空调声音太吵了，就好像卡车一样，要我们关掉。我说关掉太冷了，他说要我们盖着毛毯。我说我们现在就盖着，但还是很冷。然后我就说让我调整一下温度，我说我把温度调到了 18 度，然后我又重新启动了一下，风也调低一点，声音稍微小了点，他也满意了。然后过了会我发现确实很吵，并且它会连着地板一起震动，所以我自己也关掉了。夜里起来，觉得很冷，所以我又把空调开启了了。</p><h1 id="D7-克鲁格"><a href="#D7-克鲁格" class="headerlink" title="D7 克鲁格"></a>D7 克鲁格</h1><p>早上不到五点就醒了，然后开始排便模式。早饭我都没怎么敢吃，不过种类也一般。然后我们就坐车去克鲁格的大门。到了大门，这边人非常多，导游说要下去帮我们买票，还有核验一下，因为这里是边境了。我们则可以上厕所，因为后面上厕所就要八点半了。这个厕所很小，居然要排队，不过幸亏都是小便，我过去上了个大的。回来的时候，很多人在那个相框那里拍照，我也拍了个。墨尔本大叔想站上去拍，结果摔了一跤。我妈后来给了他一点膏药，他很感谢。</p><p>然后向导路过我，就和我说要等他，因为我英文好，我们总共三辆车，要我带一下其中一辆车，我就等他。结果大家都上车了，向导没了，我和我妈要上车，发现没有车能上去。我们的要求，就是我和我妈在一辆车上，然后不要坐中间。正好北京阿姨在招呼我，一辆车上还有两个空座，我本来以为是因为人满了，就打算上去，大不了坐中间啊，但是我妈没上去，估计是不坐中间。</p><p>我本来打算就劝我妈算了，北京阿姨看到了之后说要不我走吧，但是我看她内心好像也不是很愿意，我说你不想走就别走，他果然不走了。但是后来我知道，其实有一辆车可以满足，因为最后一排是空的，但是那辆车申报了只能坐 6 人，上去就超了。我说你向导安排下，人平移一下就行啊，结果向导说不行。所以我很生气，我说你这个明明可以安排的，不应该有我们做牺牲品。他不高兴了，我说你这样我们就耗着不走了。最后我说你为啥不安排，他说他还没来得及安排，大家就都坐上去了，我就更生气了，你不是刚安排的我么？所以我说安排是你的责任，他说 ok，他来安排。结果我就坐上了那个 6 人车，然后过一会北京阿姨也上来了。这个车子底盘非常高，需要抬很高才能上一个台阶。</p><p>无论如何，我们就出发了。出发的时候是 9 度，但是车一开有了风，体感特别冷。我是穿了牛仔裤加一个最薄的裤子，然后还需要盖个毯子才行。我一开始把 insta 360 戴在头上，然后我发现因为这个吉普车有顶，所以我根本拍不到什么东西，所以我后面改为自己手持了。其实我后面觉得这个东西套在手臂上可能会比较好。</p><p>我们一开始就看到了长颈鹿、斑马、大象、水牛(buffalo)，司机和我们说水牛是 big5，但是长颈鹿不是，我想长颈鹿不也是很大的么。这个大象很远，全车只有我用望远镜拍到了很清楚的照片，不过后面我们会看到更多大象。在斑马旁边，我们又看到了角马。据说这两个基本上是成对出现。此外，我们还看到了很多的瞪羚啥的。有一个带着驼峰的羊还是马，挺有趣的。</p><table><thead><tr><th align="center">长颈鹿</th><th align="center">斑马</th><th align="center">大象</th></tr></thead><tbody><tr><td align="center"><img src="/img/SA/cjl.jpg"></td><td align="center"><img src="/img/SA/bm.jpg"></td><td align="center"><img src="/img/SA/dx1.jpg"></td></tr></tbody></table><table><thead><tr><th align="center">水牛</th><th align="center">角马</th><th align="center">有驼峰的羊/马</th></tr></thead><tbody><tr><td align="center"><img src="/img/SA/sn.jpg"></td><td align="center"><img src="/img/SA/jm.jpg"></td><td align="center"><img src="/img/SA/tuofeng.jpg"></td></tr></tbody></table><p>九点多，我们上了厕所。然后，我发现这个好像是克鲁格的另一个大门。司机和我们说上完厕所我们就去 Skukuza，我们上完厕所，他就开上了柏油路。不过柏油路上也能看到动物。</p><p>没一会我们就在 Skukuza 停下来了，也看到了剩下来的两个车，他们之前一直没有踪影，据说他们是在我们之前 5 分钟到的。车一停，就感觉天气特别热了，不仅不需要毯子，还想把外面裤子脱了，但是我妈劝我说开起来就不热了，确实如此。反正在这边我们需要休息十五分钟，我们司机太饿了，所以还需要多休息会，不过一些团友又要买咖啡，所以大家都差不多一起出发。在这边有一个小湖，很多人坐在湖边。秋千旁边有一个白人妇女，我过去问了下有没有看到 lion，她说没有，不过昨天早上看到了 cheetah。她说基本上得早晚比较容易看到这些捕食者。</p><p>重新上车之后，我们是继续往前走的，实际上就是沿着 sabie 河的岸边走。这里动物很多，我们看到了很多大象以及河马，另外先前过河的时候，我们还看到了鳄鱼，非常近，我甚至都没有对的上望远镜，只能用 insta 360 抓拍了视频。然后路上的车就越来越多，并且都停下来了，其中，我们也看到我们团友的车子。然后导游告诉我，狮子就在河对岸。我坐在车子后排，所以我这个位置没看到。福州小姐姐 offer 帮我用望远镜拍，不过好像没拍到。不过后来狮子跑起来了，我算是肉眼看到了，随后我用望远镜也拍到了一点点背影。然后我们就掉头走了，在一个下坡的地方，我们等了几分钟，司机说狮子可能会从这边下来，但实际也没有。然后我们又到了河的另一边，去看了一些其他东西，比如河马什么的，期间我们又走了一会土路。</p><table><thead><tr><th align="center">大狮子（live photo 截图）</th><th align="center">河马</th><th align="center">鳄鱼</th></tr></thead><tbody><tr><td align="center"><img src="/img/SA/dsz.png"></td><td align="center"><img src="/img/SA/hippo.jpg"></td><td align="center"></td></tr></tbody></table><p>过了会，我们又回来了，这次又要看狮子。司机停下了，然后和福州小姐姐疯狂笔画，肯定是看到狮子了，但肯定不是眼前那个蚂蚁窝。我们花了好半天才找到了狮子，它实际上是两只小狮子，躲在草丛里面。因为狮子在跑，并且也很小，我用望远镜疯狂抓拍，就拍到几个瞬间。看完这个狮子，我们就去吃中饭了。</p><table><thead><tr><th align="center">狮子1</th><th align="center">狮子2</th><th align="center">狮子3</th></tr></thead><tbody><tr><td align="center"><img src="/img/SA/sz1.png"></td><td align="center"><img src="/img/SA/sz2.png"></td><td align="center"><img src="/img/SA/sz3.png"></td></tr></tbody></table><p>我们的中饭是在一个棚子里面吃的，不过附近也有厕所。东西不是很多，但是还不错。那个鸡腿挺好吃的，但是印象最深刻的还是意面，酸酸的，很好吃。中途导游问我们要不要明天去那个更近的赌场，结果有人说还是想看看 montecasino 的布局，所以我们就按照原计划走了。</p><p>期间，我还问了深圳宝妈是怎么值机的，加上向导也在一旁帮忙，我总算值到了最后一个不需要付费的 J L 座位。</p><p>吃完饭，就是 safari 的最后一段，回程了。这个时候感觉司机就无心恋战，想把我们赶快送回去，但即使一直开，也有不少距离呢。不过在返程的路上，我们也看到了很多好风景。例如，我们连续看到了两次公大象。第一次是单独一只，这是最近的一次，它把鼻子搭在树上，感觉在休息，然后就看到它再边拉屎边撒尿。第二次是两只公大象，结伴而行，在水边不知道做什么。</p><p>回来之后，休息了一下，然后我就出去看夕阳了。和看门的黑人小哥聊了几句，他也没去过中国，所以问了一些很奇怪的问题。比如他问我中国人是不是都骑大象，我说没有。你说的应该是泰国吧，他们确实把大象看成比较神圣的动物。然后我还问了这个营地周围会有动物出没嘛。他说有的，会有大象。但是大象实际上是比较聪明的动物，他们不会冲撞营地。然后他们说我英语很好，问我是从哪里学的，我说我们学校就会教英语，不过很多人都学的不好。</p><p>晚上我们决定把厕所门关起来开空调，因为我们发现厕所那边就是敞开的，根本不密闭，估计是为了防止水雾。一开始那个空调还好，不过随着太阳下山，温度在快速下降。</p><p>晚上我们看星星。看到了南半球特有的南十字座。看到了大角星。晚一点看到了老人星。</p><h1 id="D8-克鲁格-约翰内斯堡"><a href="#D8-克鲁格-约翰内斯堡" class="headerlink" title="D8 克鲁格-约翰内斯堡"></a>D8 克鲁格-约翰内斯堡</h1><p>早上就开始返程，返程的道路和来的时候不一样，是直接往北走了，原因大概是因为今天早上有个上帝之窗的行程。这个地方还是挺漂亮的，海拔大概接近 2000 米，据说可以远远地看到莫桑比克。我们去的时候，山谷中一点雾气没有，视野比较好。但因为最近南非在烧秸秆，所以霾很多，又没有下雨，所以整体感觉还是糊糊的。远远地可以看到一些河流，蜿蜒曲折。近处可以看到连绵不绝的垂直悬崖。我掏出望远镜架着看。</p><p>因为太饿了，我们还是在 Entokozweni 里面的汉堡店吃了汉堡，因为是用的预算点的菜，所以允许我们选想吃的，基本就是素汉堡和肉汉堡，然后一个薯条和可乐，然后还有余钱，每个人吃了个冰淇淋。冰淇淋挺好吃的，感觉用的奶很好，有小时候吃的那种感觉，很香甜。吃汉堡的时候，潮阿姨聊到他儿子是做 IT 的，喜欢鼓捣东西，我问潮阿姨你用不用 nas，她说用的。然后我们展示了手机中的 Photos Mobile 群晖软件，不过阿姨说他家的是破解的。</p><p>上了车，导游说过 20 分钟我们还是要停另一个休息区，其实本来就是要在那边吃饭的，主要还是我们太饿了。在那个休息区可以看到私人农场里面养的犀牛，也算是给我们凑齐了 big5。牛肉干是在一个超市里面买，在一楼有个专门的台子，里面放了六款牛肉干，有的是辣的，有的不辣。每个上面写了个价格，但是我不知道每个价格对应多少，贩售的黑男问我 50 还是 100 还是 200，我就买了 R 100 的牛肉干，分量多到我以为这个是 100 人民币。这个超市还有个二楼，主要是上厕所，回到一楼我还买了个唇膏 lip balm，因为感觉这边买的很多。</p><p>从这边出来，就直接返程了。中途向导在联系医院，送那个生病的爷爷去看病。等要到了约堡，天色已经要黑了，司机带我们走约堡的绕城高速。走绕城高速的主要原因，主要还是因为约堡在下班，我看地图里面全堵车堵红了。期间，我们路过了约堡第二大的贫民窟亚历山大，位于我们行进方向的右边，而我们的左边就是一些很新的四层楼公寓。导游说这种公寓在南非现在很流行，因为四层以上就必须要造电梯了。我问你知不知道索维托，他说那是最大的，不过在西南边，其实索维托也是个缩写，意思是 southwest town 的意思。说那边其实政府也在规划，因为那边有很多景点，比如曼德拉故居等。</p><table><thead><tr><th align="center">公寓</th><th align="center">在贫民窟旁边的老牌豪宅区 dainfern</th></tr></thead><tbody><tr><td align="center"><img src="/img/SA/gy.jpg"></td><td align="center"><img src="/img/SA/dainfern.jpg"></td></tr></tbody></table><p>晚上我们去了 montecasino 赌场。进门的时候，好像门卫不让这里停车，司机左右为难，导游说门卫是 nonsense，要他在这里停。停车之后，向导负责和在这里等待的一个阿姨一起将生病的爷爷和他的女儿送到医院看病。这个赌场感觉又小又老，很没有意思。赌场里面主要都是电子老虎机，只有很少的牌桌，玩的也是我不懂的东西。在里面看到一家 nandos 我拍了照片，正好看到墨尔本的夫妇，我就说这个是南非本土的快餐店。结果他们说这个在墨尔本到处都是，我觉得很神奇，难道这个是个英联邦专有的店，总部在英国？到了车上我一搜，嚯，确实是南非本土的，看来小看了。在赌场，我们看到了导游说的那种扁扁的薄薄的生蚝，大家说这个就是野生生蚝，我寻思这不就是我们在挪威吃的那个么。</p><p>出来赌场，外面传来很吵闹的鸟叫。我一开始觉得这个可能是外面的喇叭放的，但一看，这些鸟就在书上飞来飞去，我拍下了这段盛景。</p><table><thead><tr><th align="center">牛肉干</th><th align="center">鸟叫</th></tr></thead><tbody><tr><td align="center"><img src="/img/SA/niurougan.jpg"></td><td align="center"><img src="/img/SA/niao.jpg"></td></tr></tbody></table><p>出了赌场，就去了一家聚湘园湘菜馆，才非常辣，也不好吃，难怪导游之前问我们能不能吃辣。然后还有一个好像是人工肉的菜，后面那个吃素的福建爷叔问了下，说是鸵鸟肉，自己又去漱口了。我觉得和我们之前吃的鸵鸟肉不太一样，毕竟之前的像是羊肉。墨尔本大叔还请我和福州阿姨喝了啤酒，这啤酒还挺好喝的。</p><p>一路上，能看到约翰内斯堡的夜景，几个感觉，首先是这边空气真的很差，因为到处都在焚烧。然后是这个城市还挺大的，但是高楼不多，我们绕着外环走，基本只能看到那个南非第一高楼。我们住的地方也是这个高楼所在的社区，叫做桑顿，说是这边的新区，很安全。导游和我们说这边中国人真的脑子很活，都快混成所谓的黑社会了。他举了个例子说比如南非这边捕捞鲍鱼是有份额的，他们为了突破这个份额，就想到一个主意就是隔一段时间让别人举报一下自己，这样政府就会来把鲍鱼没收掉。但是这些鲍鱼政府后面也只能通过拍卖来处理，因此另一波人可以直接去把这个鲍鱼拍卖下来就行了。</p><p>我们的宾馆说是五星，其实感觉很老。我们是 438 号房间，有个窗户，但是啥都看不到。晚上，另外不少人又买了不少芦荟胶，导游让向导去带过来，向导正好晚上九点多从医院回来了，说那边做了一堆检测，排除了所有的传染病，看来只是个感冒。</p><h1 id="D9-约翰内斯堡-深圳"><a href="#D9-约翰内斯堡-深圳" class="headerlink" title="D9 约翰内斯堡-深圳"></a>D9 约翰内斯堡-深圳</h1><p>约堡这边是行李托运，托运也是要排大队的。中途，北京潮阿姨又和我讲之前自己是干测绘的，要画那种等高线图，她们还有个专门的说法。我中途上了个厕所，那边有个口的人就问我要 tax，我有点不明白，然后他和我说是个 joke 就放我走了。托运完直接就过安检，过了安检就直接出关一条龙服务。不过约堡的安检也是很慢，我们的那个队列好像一直要求开包，最后福州小姐姐等不及了，就催了下，然后就快起来了。然后这边还能看到有带武器的 checkin。出关的时候，那个工作人员看排到我了，就说自己下班了，要我们排另外一个队，也是服了。</p><p>等过完关，也没多少人了，所以我们很简单逛了免税店。小红书上搜了 amarula 这个牌子的巧克力，问了下，结果是酒，我说我要买巧克力，那人很热情，把我导航到了旁边一家店。在那一家店看到了有这个巧克力，但是太大了，我问有没有小一点的，她说没了，因为这个公司倒闭了。所以我最后随便买了另外一个小的巧克力，回来一吃，觉得还不错，但是太甜了。</p><p>在飞机上，我们是 J L 座位。K 是一个成都姐姐，她已经结婚了，有两个娃。她给我展示了在 FALSE bay 附近拍的视频，视频里面可以看到两洋交汇，颜色完全是不一样的，所以开普敦导游说的是有问题的，它也许不在那个厄什么角，但是存在这个地方的。然后小姐姐说其实你去摸海水，这两个地方的海水温度都能差很多。他说她 2013 年的时候就在南非了，她老公更早。因为担心这边的安全，就把小孩放在中国教育。</p><p>飞机起飞的时候是上午。在南非的地貌就是脏不溜的，比较有趣的是我看到了一家深坑酒店。等快到了克鲁格的时候，可以非常明显看到一道悬崖，应该就是我们在上帝之窗看到的地方，再往前就是克鲁格低地。到了莫桑比克境内，突然就有云了。不过这些云是非常小非常小的一团一团，星罗棋布，容易让人密集恐惧症都犯了。在 11.24 的时候，我们还看到有一架飞机在我们更上面飞过。再往前飞，就看到了莫桑比克的海岸，非常漂亮。后面我们就刺入莫桑比克海峡，绕过马达加斯加，往印度洋深处飞去了。在半途，我还看到了一些非常漂亮的海岛。</p><table><thead><tr><th align="center">莫桑比克海峡</th><th align="center">马约特？</th></tr></thead><tbody><tr><td align="center"><img src="/img/SA/haixia.png"></td><td align="center"><img src="/img/SA/myt.jpg"></td></tr></tbody></table><table><thead><tr><th align="center">不知名的海岛（应该是 Grande Glorieuse）</th><th align="center">云层</th></tr></thead><tbody><tr><td align="center"><img src="/img/SA/daoyu.jpg"></td><td align="center"><img src="/img/SA/cloud.png"></td></tr></tbody></table><p>大概走到维多利亚再往前一些的时候，我们就撞上晨昏线，天要黑了。我们也是在黑夜中飞过了马尔代夫。在马尔代夫和印度最南端中间，我们遇上了很强的天气，飞机绕飞了，但是还是非常的抖。</p><h1 id="D10-深圳"><a href="#D10-深圳" class="headerlink" title="D10 深圳"></a>D10 深圳</h1><p>到了深圳，下飞机就花了一个小时。然后等行李加过关又花了一小时，过关的时候每个人的包都需要安检，不过我们的肉干也顺利带回来了。</p><p>我们这个航班特别蠢，不能直挂，必须要在深圳取完行李再重新托运，所以我们又得去重新托运，总归安检了。这个安检口也很蠢，首先预检就要你扫护照，但是走没两步又要你重复一遍扫护照的动作，不知道是什么缘故。然后扫了之后，因为安检很慢，导致闸口和安检的门中间挤了很多人，队伍都得横过来排了，这样一些闸机位置比较友好的人就可以很容易插队。</p><p>回南京的航班也很蠢，莫名其妙就从摆渡车切换成了廊桥的登机口，关键是为了这个，就导致登机时间推迟了四十分钟。起飞之后非常冷，在坚持了那个蛋疼的 30min 之后，我第一时间按了铃铛，空姐问都没问就给了我一个毛毯，和我说会去调节下温度。</p>]]></content>
    
    
    <summary type="html">&lt;p&gt;7.28-8.08&lt;/p&gt;
&lt;p&gt;总的来说这是一次很幸运的旅行，因为我们的大交通航班都没有延误，并在在南非的每一天都是晴天，这是非常难得的。我感觉我们去的时候已经在往旱季过渡了。&lt;/p&gt;
&lt;p&gt;从体验上来看，因为南非是右舵，所以无法自驾。并且这个国家其实治安确实挺差的，我们只能跟团玩。跟团玩的体验其实是非常不够深入的，基本上都是坐车。我只能在夹缝间去尝试和当地人聊聊天啥的。&lt;/p&gt;</summary>
    
    
    
    
    <category term="游记" scheme="http://www.calvinneo.com/tags/游记/"/>
    
  </entry>
  
  <entry>
    <title>The Tao of making choices</title>
    <link href="http://www.calvinneo.com/2026/07/15/the-tao-of-making-choices/"/>
    <id>http://www.calvinneo.com/2026/07/15/the-tao-of-making-choices/</id>
    <published>2026-07-15T11:20:33.000Z</published>
    <updated>2026-07-15T06:36:33.506Z</updated>
    
    <content type="html"><![CDATA[<p>Life is about making choices. Decision-making must be grounded in a true, unbiased will and rational thinking.</p><a id="more"></a><h1 id="Principles"><a href="#Principles" class="headerlink" title="Principles"></a>Principles</h1><ul><li>Don’t forget to calculate the cost of ‘buying your freedom’ — freedom isn’t as cheap as one might think.</li><li>Make your choice based on your true will:<ul><li>A decision made out of fear is blind. There’s a giant gap between “what one should do” and “what one DOES NOT want”.</li><li>A decision made out of pressure is false. Responsibility is not the same as submission. It’s OK to be different — as long as it’s not for difference’s sake.</li><li>A decision made out of greed is dangerous. Risks must be calculated, not estimated.</li></ul></li><li>Avoiding choices is often equivalent to choosing the worst one.</li><li>Be wary of long-termism. Long-termism makes sense only when there’s a reasonable exit mechanism with manageable exit costs, or when one holds a dominant position.</li></ul><h1 id="“Freedom-to-choose”-and-“choice-for-freedom”"><a href="#“Freedom-to-choose”-and-“choice-for-freedom”" class="headerlink" title="“Freedom to choose” and “choice for freedom”"></a>“Freedom to choose” and “choice for freedom”</h1><blockquote><p>We have to choose for freedom, before we have the freedom to choose.</p></blockquote>]]></content>
    
    
    <summary type="html">&lt;p&gt;Life is about making choices. Decision-making must be grounded in a true, unbiased will and rational thinking.&lt;/p&gt;</summary>
    
    
    
    
    <category term="Articles" scheme="http://www.calvinneo.com/tags/Articles/"/>
    
  </entry>
  
  <entry>
    <title>新加坡之旅</title>
    <link href="http://www.calvinneo.com/2026/06/03/meet-in-singapore/"/>
    <id>http://www.calvinneo.com/2026/06/03/meet-in-singapore/</id>
    <published>2026-06-03T11:20:33.000Z</published>
    <updated>2026-09-21T15:39:13.369Z</updated>
    
    <content type="html"><![CDATA[<p>和老妈逛了逛新加坡。</p><a id="more"></a><h1 id="D0"><a href="#D0" class="headerlink" title="D0"></a>D0</h1><p>出于省钱的考虑，我们买了 PVG 往返 SIN 的飞机票。周六早上 9.35 起飞，所以我们周五就住在浦东机场了。PVG 的汉庭挺旧的，索性还算干净。</p><p>这次我们体验了机场连接线，感觉虽然快，但是还是需要花费 45 分钟。另外，因为我们住在机场附近的宾馆，所以到了机场，我们还需要坐 2 号线到远东大道等接，这有需要重新安检。</p><h1 id="D1"><a href="#D1" class="headerlink" title="D1"></a>D1</h1><p>早上六点就从酒店过去了，结果被骗了，短信说是 H 岛，实际上是 T2 的廊桥，所以我们在 PVG 等了好半天。幸亏飞机没有延误，所以我们接近是满血登上飞机。这个飞机还不错，是个 787，不仅有午饭吃，甚至每个人还有 20 min 的免费 wifi 可以用。不过据说外航现在都接入马斯克的 starlink，全程有免费 wifi 了。anyway，我还是在飞机上看完了白日梦想家这个电影，然后我觉得我们冰岛没去白日梦想家小镇那也太对了，感觉实在没啥可看的，而且这个电影没有花多少镜头在这个小镇上。</p><p>下了飞机，我还处于没有电话卡的状态呢。我之所以这么勇，是因为之前查过樟宜机场是全 wifi 覆盖的（后来发现大部分地铁站也有免费 wifi）。到了机场，感觉这里一股以前二招的那种午饭的味道，类似于一种香喷喷的油加上米饭的味道，我很难描述。</p><p>我们入境也挺麻烦的，那个护照扫描一直要 rescan，而我妈好像弹出一个比较奇怪的错误提示。后面工作人员挺不耐烦告诉我们要先去入境登记，所以我就跑到另一边的几个 ipad 那边入境登记。反正那个系统贼麻烦，填了一堆东西，末了我发现好像可以两个人写在一个单子里面，就可以少填一份，不过也没办法了。反正最后还是跌跌爬爬入境了，然后就是弄电话卡，然后去摆渡车。这个摆渡车还分了两个队，我傻等了两分钟，愣是等到一辆我们的车开走，才知道这个不是我们的队。所以我索性直接出去等了，不过也没等多久，车就到了，我们上去，总算到了 T2，走 T2 上了地铁。</p><p>我们先去的酒店，走索美塞下车，走一会就到了。不过这里路口很扯，那个 Orchard 路，一边有红绿灯可以过，一边没有。去宾馆就还是挺顺利的，也没要交什么城市税，也没有刷信用卡授信。这个宾馆其实还行，无非就是床小了点，设备旧了点。</p><p>放下东西，喝了点厕所的水，我们就出门。zhangqi 还在外面，所以我先带我妈去逛逛附近的福康宁公园。我们是从酒店出来之后，在 Penang 路上穿过 Istana Park 然后走到多美歌站附近，中间看到一个非常高的楼，是全季酒店，这里全季酒店非常贵，我们没有住。再往前走，其实有个电梯可以上去，但是我们选择走前面的福康宁隧道，进去隧道就发现很多人在排队，也不知道拍什么。实际上后面看小红书才知道这个是福康宁树洞，非常有名。</p><p>然后，我们就进入了福康宁公园的地界。在这里有很多以前的军事设施，例如地堡，指挥基地等，但是我找了半天都没有找到。反倒是首先找到了一个建筑，里面是一个多层的博物馆。</p><p>从博物馆出来，可以到好像是山顶的地方。山顶有一个非常大的门叫 Fort Gate，很多人在那边合影。Fort Gate 面对的那一条下山路，两边是堡垒墙残垣。</p><p>这里有一个叫 Forbidden Spring 的地方，我们顺着路牌就被引导下山了。这个禁泉，实际上就是新加坡之前的王室用来洗澡的地方。这边下山还是挺友好的，都有电梯。不过下山之后，我们就不愿意再上山了。山下，正对着的是一个儿童游乐园，非常小，但是里面照样有小孩子在玩，玩了一身沙子。然后右边是新加坡的国家剧院的遗址，现在遗址上是一些雕塑。</p><p>从地图上看，我们还有东南角的来福士宫，福康宁灯塔等景点没有逛。我们沿着左边那条的路往东走，这条路在山下，其实就是市政道路了。此时，福康宁公园里面有一条平行的栈道，但是在高处。我们并不希望走台阶爬上去，所以希望前面一直走就能有个缓坡，但并没有遇到。最后，我们还是爬上去了。其实上面这一段叫五王径，是一个景观栈道。在上面，可以看到脚下的游船码头，再远一点的 CBD 等。我感觉新加坡的楼都挺窄的，并且感觉都彼此挨着，有种香港的感觉。</p><p>爬上去之后，参观了一下来福士宫，这里旅途随身听特别讲解了一个叫 Time Ball 的东西，据说是为了给市民校准时间用的。从灯塔再往北走，也是个栈道，还会路过一个叫 Utama Garden 的地方，我们简单看了下，就准备去吃饭的地方了。幸亏之前约的是福康宁旁边的克拉码头，所以我们 15 分钟急行军就走到了。</p><p>晚上和 zhangqi 吃了饭。好久不见，原来他已经工作了。据说是在 HW 新加坡 branch，然后他们那并不加班。zhangqi 请我们吃了一个 JUMBO 的海鲜。他家很有名的是螃蟹，有两种做法，我们点了黑椒的，因为怕辣。但其实黑椒的也是挺辣的。这里的螃蟹除了贵，没啥问题。特别惊喜的是，肉很多。因为国内这种螃蟹或者龙虾，基本上咬开厚厚的壳，里面的肉是非常少的。他们家的薏米水挺好喝的，并没有加什么特别的调味，解辣，我们后面还加了一扎。我们还点了这边的一个非常有意思的小鱿鱼，感觉是像零食一样，一口一个，很酥脆。比较有意思的是 zhangqi 第二天就要去深圳，所以我们附近逛了一会，没有找到榴莲店，就结束了。</p><h1 id="D2"><a href="#D2" class="headerlink" title="D2"></a>D2</h1><p>今天一天都是植物之旅。</p><p>早饭我们吃的是亚坤。亚坤最有名的是它的生鸡蛋，反正吃起来也不是很好吃吧。他家的面包挺硬的，然后酱又齁甜，我猜想是不是和英国学的那种难吃的早饭。</p><p>早上首先是按照我从小红书临时搜到的线路 city walk，第一站坐到 city hall，看一下几个教堂。应该是周日的缘故，所以大家还在做弥撒，教堂不太能走进去。后面看了下旧禧街警察局，发现不就是昨天从福康宁公园下来的地方么？然后仔细一看，这边好像是新加坡现在的什么文化和青年部。再往前走就又是 clay quay 了，我们就没有再进去逛，而是往牛车水方向走。不过我实际感觉这段又累又没啥可看的，有个楼上涂鸦了一个花旦，我妈站在天桥上拍了下。进入了牛车水附近，路牌也会标注中文，还是挺有意思的。总而言之，在经过了老巴刹之后，我们就开始往喷水狮子那边走。路上有趣的是我看到了头条的新加坡办公楼。</p><p>这一段路还是很远的，相比远，它还很晒。到了喷水狮子那里，遮蔽越来越少，原来还能有连廊或者树木遮阳，现在直接在海边暴晒了。我们拍了拍现在已经近在咫尺的金沙三炷香，然后去狮子那边。其实在大狮子旁边的树荫下，有个喷水小狮子。大狮子旁边的人还是很多的，我们在不同角度拍了不少照片，中间一家印度人和我们互相交换了拍照。</p><p>我看了下去滨海湾的公交，地铁是非常绕的，我也不太想打车或者坐公交，最后还是决定走路过去。不过走路过去好像也不是很远。这里我原以为滨海湾花园就是在金沙那三炷香顶上，后来才知道，这是一个专门的地方，在金沙的东边。一路上走着，听见说滨海湾的花穹和云雾林都很冷，想着我今天短袖短裤别给搞感冒啊。我还在想自己有没有带感冒药来，好像新加坡不给带药，我带了很少的药。滨海湾花园有点类似于一片大公园，我们需要走一个小匝道绕进去。进去之后啥都没有，我还是看了路牌，换了一对导航才确信自己走对了。不过深入走了一段，很快就能看到那些长得很神奇的人造树，我确定自己走对了地方。然后就是买票，这边如果现场买票贼贵，一个景点都要 50 新。所以我搜了下 klook，两个人才 240，给我便宜哭了。我甚至担心这个是假的，不过我们很顺利就进去了。</p><p>花穹进去的通道，觉得很冷，但是等到了那个冷室里面，反而不冷了。这是因为冷室是玻璃的，所以太阳照进来暖洋洋的。这个冷室挺大的，分为了好多区。我刚进去往左走，分别是南非和南美。然后再深入，则可以往下或者往左上走。往左上走是去加州区，往下走则可以到一个庭院，里面是土耳其主题的花卉展，感觉最近是在和土耳其搞活动。说到这个，其实刚才一进来就看到一个土耳其航空的飞机，这我总算是回过味来了。这个土耳其区里面搞得像小迷宫一样，有很多小径，在这些小径旁边中了很多的花。并且这些小径上面有的是有屋顶的，实际上应该是称之为廊道，这些廊道也是很有土耳其的特色。</p><p>回到出口那，其实右边还有一堆地方没探索，主要是猴面包树区和多肉植物区。比较有意思的是这个区域中还陈列了一堆插花作品，我拍了一些，感觉都挺有创意的。</p><p>期间，我和 Bugen 约了晚饭，是 Little Elephant 啥的店，一个泰餐。我看了下，发现它离植物园也不远，仔细研究了下，我发现可以从植物园北门逛到南门，这样正好可以坐地铁去那边。</p><p>从花穹出来，就直接去云雾林了，距离很近，其实这两个甚至共用了一个出口。一进云雾林，就看到一个巨大的瀑布，非常壮观。然后再往前走就是一些恐龙，比如霸王龙，梁龙等等，头还能动，还有各种声光特效。我感觉挺违和的。不过云雾林非常有意思的地方是你可以坐电梯到 6 楼，然后爬到 7 楼，再往下走。因为这个展区实际上是为了展示热带雨林从高海拔到低海拔的植被的变化，所以这么做我觉得挺有意思的。类似的，我们晚上在国家兰花园里面，也看到一个类似的展区，按照海拔展示了不同的兰花。</p><p>云雾林有个特色就是下雾，进门去的时候，我们留意了下，下一场是 14.00。我原以为他会喷出一种西游记那样的烟雨蒙蒙的仙境的感觉，但实际上它就是搞了点小雾气洒洒水而已。仰头看，天上的两个爱心栈道依然可以看见。</p><p>我们并没有等到雾气全部消散，就直接往下走了。走到云雾林下面几层，展示的花更多了。比较有印象的是展示了好几个非常小的兰花，得用放大镜才能看到。</p><p>从滨海湾花园出来，可以看到对面的摩天轮，据说这个摩天轮贼贵。准备去吃中饭，我们又是绕来绕去兜了不少路，期间还走上一个造型挺漂亮的桥，在上面可以看到对面的喷水鱼尾狮。走到一个商场的 B2 去吃一个肉骨茶，据说是米其林，然后点评也是排名前几的。结果一到那边发现 B2 是个食阁，所以米其林这么没牌面的么？食阁大概就是没有一个专门的店面，只有一个档口，然后中间有一些共享吃饭的地方。把饭拿过来之后，就在那边吃，吃完要自己送餐盘到规定的地方，然后还要按照是否清真来分类放置。</p><p>吃完饭，我们准备走路去地铁，前往植物园，路上还发现金沙这个地方居然有赌场。我之前从没见过赌场，发现好像进去居然要登记护照。并且这个赌场看起来很奢华，占了一层，金碧堂皇的。这个商场的指引很奇怪，我们要去地铁站，按照商场里面的箭头，我被导到了商场外面，在外面走，我们还路过这个赌场开在外面的门，但是是常闭的，写着什么“尊上禁止进入”之类的话，感觉带着非常冷漠的客气。但是走着走着，又被带回到了商场，并且到了这个赌场的另一面，我感觉其实我们是可以直接穿过商场走到的。</p><p>下了植物园地铁站，出到地面就是植物园。这个植物园是免费的，只是里面的兰花园要收费。我们的时间不算多，所以只能简单逛逛。刚进门的地方有一些竹子和攀爬植物，然后绕来绕去走到了一个植物园东边缘的道路上。植物园是半开放的，这个道路走着走着就能走到外面的公路上，自然这条路也没啥风景可以看。但是我很快在地图上看到有个叫芳香植物的地方，所以我就想过去闻闻香味。所以我们又找了个岔路绕了点路回去，走到了一个小山上。在快走到的时候，我发现还有个园区是有关药用植物的，然后旁边还有个关闭着的园区写着是有毒植物，我们远远看了看，基本都不认识。不过药用植物里面有不少也挺香的，反而是走到芳香植物那个片区，我预想的那种芳香满庭的场景并没有发生，我们还是得凑到花上去闻才行。</p><p>从芳香植物下来之后，我们就准备前往兰花园了。这也是比较顺利的事情，因为刚才这一阵逛，我们总算是走到了植物园的核心游览路线上了。不过路上我看到一个热带雨林片区，里面黑黢黢的，一开始不敢走，怕蚊子。不过后来看到两个老外进去了，所以我也返回，也带着老妈扎了进去。因为怕蚊子，所以我走的快，全程基本上都没有仔细看，只是用手机拍了个全程视频。结果其实还好，没有被怎么咬到，至少比昨天在福康宁要好很多了。老外倒是被我们甩到后面了。中间还看到一棵大树，STRANGLING FIG，它的牌子上写着没有游客能够走过这个树而不驻足观看的，因为它真的特别特别粗。</p><p>到了兰花园门口，准备买票。我看了下 klook 好像没优惠，就直接走信用卡了。但好像其实你点进去，是有折扣的，不知道这个软件是怎么设计的。这个地方收费也很离谱，最便宜的只要一块钱，我们这种啥弱势群体/公民身份都不沾的就得 15 新奉上。入口的人还问我妈有没有满 60 岁，我也比较好奇这个是不是纯看诚信？</p><p>后来我总结，兰花主要是根和花。它的根有点类似于水仙花那样长，并且很容易寄生在别的树木上面，在一些地方，我看到它甚至是在钢筋上面的。</p><p>从兰花园出来，基本就没啥时间再逛了，所以我们赶快走到南门的地铁站那里，坐地铁到吃饭的地方附近，然后又走了一段。这边有个丁字路口非常不好过马路。</p><p>晚饭时间，点了冬阴功，感觉更酸辣。点了点香茅饮料水，感觉是真的挺好喝的，我和我妈后面又补了一杯。另外，沙拉也挺好吃的。我们在那里谈了不少东西，感觉非常传奇。有一点我比较震撼的是知道现在做 LLM 的人基本 90% 都是中国人，不过处于合规的原因，很多都得出国了。我还请教了 vLLM 和 SGLang 的区别，据说现在两个同质化很严重。SGLang 只是一开始引入的结构化生成语言（也就是得名）比较有意思，不过现在都是 OpenAI 的接口了。说到这，他也提到他现在在做的一些工作，我也对 vLLM 的接入层进行了学习了解。</p><p>然后我们就回宾馆了。</p><h1 id="D3"><a href="#D3" class="headerlink" title="D3"></a>D3</h1><p>今天一天都是动物之旅。</p><p>早上起的比较早，先去地铁站附近的大南洋吃了个早饭。是海鲜面啥的，感觉还行吧。这个是个餐厅，因此就没有要我们自己交餐盘。</p><p>然后就是去动物园了，我们走索美塞上车，直接可以坐到卡迪。走卡迪下车，没几步就是 M2 的公交车了。其实在地铁站里面是有个路牌的，我当时还看着 google 地图找了一阵子。</p><p>这个 M2 也是奇怪，前面的车刚坐满，一个人没往上站，就让我们坐下一辆。但是下一辆又是站满了人，不知道是什么目的。总之也是晃晃悠悠才到了动物园片区。这个片区非常大，并不只是我们知道的五大动物园，还有一堆探险园啥的，都挤在一起。M2 在这个园区总共停两站，第一站主要是飞禽馆，我们要去的是第二站，也就是大部分场馆在的地方。</p><p>我的计划是新加坡动物园和河川馆，因为飞禽世界在另一个区所以就不去了，而 night safari 大家都说啥都看不到。</p><p>先去的新加坡动物园，在 klook 上买的票，也是很省钱的，两个人才 358。不过这里坑的是最好买的时候就选一下日期，不然就要在一个很难用的网页上选日期，我们在门口搞这个卡了很久。另一个是最好每个人分开来买，这样优惠最高。我看了一些七拼八凑的攻略，也试了下旅途随身听，感觉实际都不如 Mandai 那个 App 有用。</p><p>因为有短暂的排队，以及弄 klook 导致需要重新排队，我们墨迹到快十点才进园，然后我就直奔那个海狮表演。进去的时候，走了下树冠小路，只有一点点短，比自己预期差了不少。从上面下来之后，都是有凉棚的路，当然平行的也有一条树林小径，这个后面我们也走了一遍。</p><p>然后我们就走到动物园的中心，也就是餐厅，什么阿明餐厅啥的，这边的路是有顶的，感觉像是半封闭的室内。但是走到头，往左拐，就感觉出了这一片室内区，走到了露天。再往右拐，走一会，就到那个剧场了。后来我发现这个海狮表演应该是这个动物园完成度最高的表演了。</p><p>海狮表演结束之后，好像是可以上前面合照的，但是我们赶时间，就赶快去那个萌宠表演。这可要了大命，萌宠表演在另一个非常远的地方。我们后来回想，其实不如就在这里拍下照，等 11 点的另一场表演结束算了，萌宠表演可以下午看。而我们实际上是先急行军过去看了萌宠表演，然后下午两点半临走前，又绕回来看了这个剧场的另一个表演。</p><p>Anyway，我们走了点回头路，然后又穿过了整个绕来绕去的爬行馆片区，然后走到了一片 kid’s world 区域。我们在那里来回绕了半天，从冲淋区走到萌宠区，终于在一个类似于露天广场的地方找到了这个表演。当时表演已经进行了一部分了，我们看的部分是一只羊、一只猫、一只马和一只狗，我的第一反应是方舟动物园里面的萌宠不会就是照着新加坡动物园做的吧。不过这个表演与其说是才能展示，不如说是行为展示。羊象征性走了下秋千，但这个已经是最给面子的了。猫就是慢慢的走，然后穿过一个比一个小的圈圈。为了凑时间，甚至还邀请了一个大人和一个小孩上去钻更大的呼啦圈。马的展示就是看了四个刷子，然后刷一下马。因为马脸比较娇嫩，所以有个专门的刷子，感觉过的比人还好。那个叫 Lucas 的狗是最离谱的，啥都不做，就只会握手。</p><p>总之看完这个表演，我们才开始逛动物园。首先是先把萌宠这个区给逛完，然而我们也失算了，因为这个区实在是太乱了。我的想法是从 kids world 开始逆时针逛，所以大概是把来的时候的爬行馆给逛了。我觉得这是对的选择，因为新加坡动物园的爬行区确实很赞。南京红山森林动物园其实只是学了新加坡动物园的一些管理思想吧，比如不训练动物表演，但其实展出的动物类型还是差别蛮大的。比如我们就看到一个大蜥蜴，已经觉得很霸气了，但一看，是什么科莫多巨蜥，我一直以为这个是某个已经灭绝的牛逼生物呢。过了巨蜥，还看到不少超大的乌龟。而爬行馆里面更是五花八门，比如说有两个头的蜥蜴还是蛇，有传说中的西部菱斑响尾蛇。</p><p>这里还有一个鸟/蝴蝶馆和脆弱雨林展区，我们也在稍后逛过了。鸟馆里面，与其说是鸟，我见到最多的是果蝠。爬到一个台子上面，可以离他们很近观看。雨林展区里面也是挺大的，感觉和爬行馆里面展示的东西差不多。</p><p>新加坡动物园还有一个特色的猴子比较多。从鸟馆出来之后，我也看到黑冠猴啥的。路上还看到有小蜥蜴在爬，还拍了视频。然后我们就离开这个片区往回走了，然后走到一个 Sensory Garden 里面，这里面是个南美巨骨鱼，那鱼还挺大的。然后这一圈又是一个猴子岛，里面有很多猴子，这一片其实就是灵长类王国。我们绕了一圈，看到了不少猴子。</p><p>出去之后，就是一个埃塞俄比亚大峡谷展区。里面展示了一些土著的建筑，以及一个非常大的狒狒园区。狒狒看起来还是非常离谱的，屁股又红又大，感觉像是肿瘤。</p><p>最后一站看了亚洲象，然后就回到早上那个剧场看最后那个表演。中途，我准备抢 16.30 的票，发现网非常拉胯，硬是没抢到。那个表演上上了很多动物，很多动物都感觉挺不自愿的，上来亮个相也不表演就走了。我觉得其实这个也不能说新加坡动物园就是搞动物表演的，人家只是做了行为展示，我觉得也挺好。相比之下，红山动物园的行为展示更自由一点，我觉得不好的地方是红山现在人太多了，导致很难看到。所以像新加坡动物园这样搞一个大剧场让大家都能看见挺好的。</p><p>从新加坡动物园过来，就直接去河川馆了。这次吸取经验，让我妈自己买指定日的票了。进去之后，发现这个馆好像不是很大。我们是朝左走，好像是可以看大熊猫，虽然我也不是很喜欢大熊猫。它这个河川馆的意思是展示了全世界的各个河流的生态，比如尼罗河、澜沧江等等，基本上是一条单向的步道，走到大熊猫那边是长江展区。看完之后，相当于就走了一半了。跨过一个桥，就到了另一边。另一边主要就是 16.30 的表演，以及一个 5 新的船。我买了票，说是要排 30 min，实际上 12 min 就上了。我们一共坐了三次，3 4 5 排都体验过了。这个船还是挺好的，首先它不是很吓人，也没有溅很多水出来。然后，它路过的动物都是比较活跃的，比如食蚁兽、朱鹮、猎豹、卡皮巴拉，还有一些猴子等。</p><p>坐完船，其实前面就没啥了。有印象的主要是一个亚马逊主题，里面有一个非常深的水池，里面养了海牛等等之内的大动物。可以从一个海底隧道进去，然后绕着圈圈一直看到最上面。不过因为我去过大阪的海游馆，所以我觉得也就 soso。</p><p>从动物园出来，准备在卡迪地铁站附近的超市买点水果，都准备买了，发现原产地是澳大利亚，感觉没啥意思啊，就没买。这边水果品种也不多，4 个芒果 4 新好像倒是很便宜，但是特别大，感觉带不走。</p><p>因为 zhangqi 推荐了白鸡尾饭，所以今天我在 Orchard 站附近的一个商场的食阁里面找到了一家也是很有名的天天海南鸡饭。这个商场是真的破，感觉和兴化的招商城有的一拼。但里面剪头美甲真的好贵，剪头要 25 新，美甲要 100 新，而且也不是那种很装修豪华的店，就跟街边的小店一样，感觉新加坡是真的贵。天天家的点菜，我是真的不知道了，因为我不知道白鸡尾饭用英文怎么说。幸亏那个店员会中文，所以我跟他说他是听的懂得。好像这个就是海南鸡，只是部位不同。一般的是带骨头的，但是鸡尾是不带骨头的，并且还特别嫩。</p><p>从这个店出来，找到一家 fair price 超市，准备买点水果。这边不少水果奇形怪状，我找了半天，最后用 kimi 和 chatgpt 帮忙选了一个叫 salak 的水果。吃着挺好吃的，很香，肉也紧实，水不是很多，吃在嘴里还有点脆。</p><p>回到宾馆，问了下服务人员，说是可以免费寄存行李的，只要不过夜。</p><h1 id="D4"><a href="#D4" class="headerlink" title="D4"></a>D4</h1><p>今天起的更早了，原因是我想先出去逛一逛，然后回来洗个澡再退房，不然我一天汗流到屁股沟子里面很难受了。昨天晚上我就在纠结到底去哪里，早上去圣淘沙好像不太来得及，但是那些博物馆又是十点钟才开门。正好我妈昨天晚上说见了一大堆外国人，所以我寻思就带他去看看各个民族的街区吧。</p><p>所以第一站我们去了小印度。这时候，旅途随身听就起到了作用，对于这个景区，它规划还是挺好的，讲解也不错。我们先去了竹脚中心，我妈有点想吃印度飞饼，但是我们找了一个摊子，发现人家说没开门，也不知道真的假的，我看他倒是做的热火朝天的。anyway，我们逛一圈也没看到有啥可以吃的，就出去继续逛了。期间逛了一些某个华人的故居，甘地纪念馆，一些印度不同地方风格的寺庙。比较有趣的是在一条街上距离 30 米内有一家印度庙，一家观音庙和一家清真寺。</p><p>逛完小印度，准备去苏丹回教堂和甘榜格兰。不过发现与其坐地铁，好像走几步就到了。中间我还试了下这边的甘蔗汁机器，感觉不错。这边甘蔗比较有意思的，它好像一节节纺锤一样。走到武吉士附近，能看到一个 Rochr 运河，以及来福士医院。我妈觉得挺神奇的，为什么这个医院门口没有像江苏省人民医院门口全是人挤人。苏丹回教堂看着挺漂亮的，不过没开。往前走一点就到了甘榜格兰，它感觉就差强人意，其实就是个小庙。而且也没开放，还有墙围着，所以我们就准备往回走，去看看马来文化园。这个地方好像之前说黄循财来过，最近还在免费期。</p><p>到了文化园，还差几分钟 10 点，准备等一下。我妈上了个厕所，我找了半天入口，发现在另个建筑中。走进去发现这其实是一个小馆，并不是很大，两层楼，每层楼有四五个展厅。刚进去的时候，门开不下来，然后找到那边办公室，说是免费的，但是还是要先给我们一个 tag 贴在衣服上，比较有仪式感了属于是。一楼是新加坡国王，以及殖民相关的，比较有印象的是有个抓大象用的矛。二楼是近代相关的，还有一个专门的马来西亚电影艺术家展厅。这里比较有意思的是二楼的一个像船一样的东西，其实叫 Congkak。另外还有个刨椰子的东西。</p><p>我们是匆匆逛完这个文化园的，然后就快速往宾馆走。路上又看到那个回教堂，但是抓紧时间，也没有再进去，从外面看了下，里面全是人。到了宾馆，洗了个澡。我妈把我想扔掉的衣服又偷偷背回来了，不过我还是想办法扔掉了个白的。</p><p>从宾馆出来，这次就直接退房了。因为要去新加坡国家博物馆，所以路线还是和第一天一样，路过多美歌，以及福康宁树洞，这一次总算是可以看看长什么样子了。我们路过 Istana Park 的时候，我突然意识到，对面那个戒备庄严的地方，可能就是新加坡的总统府，后来发现好像确实是这样。其实总统府每年是有开放日的，不过我前几天搜了下，今年的开放日距离都很遥远。</p><p>到了新加坡博物馆，发现太阳是真的毒辣。此时，刚好快 12 点，我寻思博物馆也不知道要逛多久，不如吃个东西。一搜，结果附近有一个便宜米其林，这就过去吃了。这个米其林并不是一个饭店，而是开在一个大学旁边的一个小摊子。在这个小摊子旁边，摆了一堆椅子和桌子，所以我们拿到东西之后就坐在那边吃。这边的店员是一个穆斯林小姐姐，不过英语还是不错的。吃的有点小辣，也没有水。我去旁边的橙子机买了个橙汁。</p><p>吃完，就去博物馆。这个博物馆应该是我看过最垃圾的博物馆了。因为它的主展厅是关掉装修的，但是门票还是照收不误。我们只能逛两个特展厅。一个特展厅在 2F，非常无聊，是一个影片。然后他有一个长长的旋转走廊，可以从上走到下面，然后旁边展示了新加坡的历史，但好像还是倒序的，不知道为啥。反正到最下面，就展示了一个螃蟹，然后每过五分钟就可以用进来的时候送你的那个手表贴上去，就有一个很愚蠢的互动，好像这个螃蟹上面长出了一些树啥的。然后看完之后，还要把那个手表还回去，我还以为是送我的呢。</p><p>下面的那个特展厅还有一些东西可以看，不过他非要你把书包背在前面，直接把我颈椎病又搞出来了，总之就是拉完了。里面介绍了新加坡被殖民的历史，一些先民的活动，来自中国的移民等等。有一些体验项目，比如划船啥的，其实也没啥意思，我们也没参加。</p><p>从国家博物馆出来，根本不想再去逛其他博物馆了，所以打算就去爬山，那边黄昏的景色不错。但是我妈好像也不想爬山，所以我最后决定就去圣淘沙逛下。圣淘沙其实就是坐到 Harbourfront 地铁站，然后在 Vivo 那个商场可以走海滨步道或者坐小火车过去。不过我想先尝尝这里的糖水，其实真的是非常好吃的。就是在顶楼食阁那里，特别推荐的是一个糖水里面有一个酸溜溜的那种果皮一样的东西，不知道是什么，但是确实很好吃。吃完之后，就走到商场屋顶平台看了下，其实就可以看到小火车和对面的圣淘沙岛了，另一个方向还能看到缆车。</p><p>我们决定走路过去圣淘沙岛，然后坐小火车回来，这样一分钱都不要花。走路过去其实一点都不远，也不是特别晒。走到圣淘沙岛之后，需要在一个停车场里面绕半天才能走到小火车那里。我们直接坐到 Beach 站下来，然后就往最南端那个景点走过去。</p><p>其实之前研究攻略，都说下小火车是可以坐那个免费游览车过去的，但是我们沿路找了半天，并没有找到如何乘坐我们需要的方向。走着走着，我们发现，好像并不是很远啊。其实一路上，我们前面是在柏油路路边的遮阳走廊下面走的，走着走着，就会走到一个海滨浴场的沙地里面。</p><p>然后我们就看到了那个吊桥，其实距离非常近了。这个吊桥很窄，在上面错身都困难。我们过去的时候，还有人一起摇来摇去，挺有趣的。过了桥是个岛屿，下桥的那个口子上看到有一个牌子是亚洲大陆的最南端。再往前走，是一个双塔，中间有个桥。实际上就是你可以站上去看。南边就是新加坡海峡，理论上就是看到印度尼西亚了。北边就是圣淘沙岛。</p><p>我们坐了圣淘沙的地铁回去，这个地铁的终点站居然就在商场里面。我们从商场下来，就坐地铁准备去机场了。</p><p>到了樟宜机场，首先去 Jewel 看了下那个著名的瀑布。那里有个专门的，面对着瀑布的商业体。我们从顶楼的地方一直走到底楼，然后准备去值机。我们是在 T1 那边值机的，要排好久的队，因为只有一个柜台在处理。然后我们和前面人讨论飞机可能延误的事情。</p><p>然后，我就琢磨用小火车去看那个瀑布。从小红书的攻略，这个只能是从 T2 到 T3 还是 T3 到 T2 的，因为另一个方向容易被对向挡住。反正我就这么绕了一圈，把 T1/2/3 都逛了一遍。</p><p>在 T3，我想去坐那个滑梯。所以我从楼上问到了地下，先是问了个黑人小哥，那个 big slide 在哪里，小哥说 WTF？我又问了下，他说不知道。然后我又去问了机场工作人员，说是在到达层。我又过去看，发现那边有好多吃的，果然就饿了。我妈在哪里倒了点水喝。然后我发现找不到，就问了另外的工作人员。那边人明显知道很多，先问我是要坐还是要看，我说要坐，她就说在楼上，然后还提醒我要在那个 app 里面预约，这个我是知道的，所以感觉他应该是真的懂吧。不过我上去之后并没有找到，反而是走到了一个高级餐厅还是酒店里面。</p><p>回到 JEWEL，瀑布顶端是可以上去的，上面还有很多项目可以玩。但是我们去的有点晚，导致去那边的电梯都关门了。不过有一个电梯还是可以上到 roof 上，可以看到最后一批上去的人还在玩。roof 上还有好多餐厅。</p><p>我们还吃了 Mr coconut 我点了经典版，加了个冰淇淋球，非常好吃，就是太冷了。</p><p>我们在 T4 吃的晚饭，是一个印度食阁。就是简单的印度饼+咖喱，但是觉得很好吃。</p><p>T4 也有个小滑梯，很多小孩子在玩。等他们玩完了，我也去玩了好几次。</p><p>回程是个红眼航班加窄体机，人都麻了，反正我颈椎很不舒服。到了 pvg，还需要坐机场联络线去虹桥机场再回去。</p>]]></content>
    
    
    <summary type="html">&lt;p&gt;和老妈逛了逛新加坡。&lt;/p&gt;</summary>
    
    
    
    
    <category term="游记" scheme="http://www.calvinneo.com/tags/游记/"/>
    
  </entry>
  
  <entry>
    <title>Vector Index 相关技术调研</title>
    <link href="http://www.calvinneo.com/2026/05/22/on-vector-index/"/>
    <id>http://www.calvinneo.com/2026/05/22/on-vector-index/</id>
    <published>2026-05-22T15:09:06.000Z</published>
    <updated>2026-05-22T09:18:38.027Z</updated>
    
    <content type="html"><![CDATA[<p>Vector Index 相关的一些总结吧。</p><a id="more"></a><h1 id="存储"><a href="#存储" class="headerlink" title="存储"></a>存储</h1><h2 id="综述"><a href="#综述" class="headerlink" title="综述"></a>综述</h2><p>目前存储格式基本上分两种思路：</p><ul><li>基于图的方法，如 HNSW、Vamana / DiskANN<ul><li>结构：向量是图里面的点。选择比较近的向量，或者能够向其他 cluster 连通的向量（Vamana）去连边。</li><li>搜索方式：从入口点开始，查找当前节点的所有邻居和待查询向量的距离，然后选择最近的跳过去。重复迭代，直到找不到更近的邻居。</li><li>特点：Accuracy 高，但如果图太大或者结构太复杂，IO 性能不是很好。特别地，HNSW 得全部放在内存里面。</li></ul></li><li>基于聚类的方法，如 IVF-PQ、SPANN、SPFresh<ul><li>结构：先用 KMeans 等算法对向量进行聚类，然后把这些向量都挂到对应的 cluster 下面，类似倒排索引一样（Inverted File / IVF）。</li><li>搜索方式：找到最近的几个 Centroids，把倒排索引里面的向量捞出来比对。</li></ul><ul><li>特点：对磁盘友好，数据局部性好。</li></ul></li></ul><h3 id="量化技术"><a href="#量化技术" class="headerlink" title="量化技术"></a>量化技术</h3><h2 id="Vamana-算法"><a href="#Vamana-算法" class="headerlink" title="Vamana 算法"></a>Vamana 算法</h2><p>Vamana 没有 HNSW 那么多层级，它只有一层图。这一层图中，既保留了 HNSW 中最下面的稠密层类似 kNN 那样的边，但是又保留了一些长程边。这样，兼顾了 HNSW 稀疏层的“快速跨越跨度”能力和稠密层的“局部精细搜索”能力。</p><p>因为只有一层，所以 Vamana 是把一个节点及其所有的邻居节点、连同它们的原始向量，物理上紧密地排列在磁盘上的相邻位置。当算法访问节点 $A$ 时，直接把 $A$ 的向量和它所有邻居的信息整块（Block）读入内存。Vamana 严格限制每个节点的最大邻居数（例如最多 64 个）。这样可以确保“节点+邻居信息”的大小绝对不会超过磁盘的一个 Page（通常是 4KB）。</p><h3 id="具体实现"><a href="#具体实现" class="headerlink" title="具体实现"></a>具体实现</h3><ol><li>搜索时的 Tradeoff：参数 $L$<ul><li>$L$ 设得大： 搜索时在内存里维护的候选队列更长，探索的分支更多。代价是更慢（计算距离和磁盘 I/O 次数增加），收益是更准确（Recall 更高，不容易漏掉正确答案）。</li><li>$L$ 设得小： 搜索时只看眼前最近的几个节点。代价是容易掉进局部最优解（准确率下降），收益是极速返回。</li></ul></li><li>建图时的 tradeoff：参数 $\alpha$<br> $\alpha$ 是 Vamana 独创的 RobustPrune 算法中的参数，通常 $\alpha \ge 1$。它的真正使命是控制长程边（跨区域高速公路）的生成，从而从根本上决定搜索的跳数和效率。<br> 假设在建图时，节点 $A$ 已经连了邻居 $B$，现在算法在评估要不要保留通向远处 $C$ 的边：<ul><li>当 $\alpha = 1$ 时（严格剪枝）： 算法非常“近视”。只要通过 $B$ 通过多条短边一点点挪去 $C$ 的距离在数学上还能接受，它就会把 $A$ 直连 $C$ 的边剪掉。最终图里全都是局部短边。由于缺乏跨越巨大空间的长程边，搜索时需要一步步缓慢挪动，跳数急剧增加，导致搜索非常慢。</li><li>当 $\alpha &gt; 1$ 时（例如 1.2，适度放松）： 算法变得更加包容，会刻意保留一些跨越较大空间的长程边。这正是 Vamana 能用单层图匹敌 HNSW 多层图的奥秘。这些长程边充当了“高速公路”，搜索时能极快地跨越广阔的向量空间逼近目标区域，不仅让搜索变快（跳数大幅减少），还能跳出局部死胡同（提高准确率）。</li><li>当 $\alpha$ 极大时（例如无穷大）： 算法完全不剪枝，直接退化成传统的 kNN Graph（每个点只连物理上绝对距离最近的几个点）。整张图彻底失去长程高速公路，且极易断连成一个个孤岛，导致全局搜索常常在中途断掉，准确率会暴跌。</li></ul></li></ol><h3 id="α-的判断条件"><a href="#α-的判断条件" class="headerlink" title="α 的判断条件"></a>α 的判断条件</h3><p>在 Vamana 为某个中心节点建图时，它会按距离从近到远遍历所有的候选节点，并使用以下公式来决定是保留还是剪除（Prune）一条边：<br>如果在候选池中，存在一个节点 $p’$，满足以下条件：</p><p>$$\alpha \cdot d(p^*, p’) \le d(p, p’)$$</p><p>那么，系统就会剪掉中心节点 $p$ 直连 $p’$ 的边（将其从候选池中剔除）。<br>这里面的三个变量代表什么？</p><ul><li>$p$：当前正在建边的中心节点。</li><li>$p^*$：刚才已经被 $p$ 选中的近邻节点（已经决定要连边了）。</li><li>$p’$：还在候选池子里，等待被评估要不要和 $p$ 连边的目标节点。</li><li>$d(x, y)$：表示两个节点之间的距离。</li></ul><p>不妨令 alpha 为 1，这也意味着：如果目标节点 $p’$ 距离已选邻居 $p^*$ 的距离，比它距离中心节点 $p$ 的距离要小，那么 $p’$ 就不要连一根线去 $p$ 了。那么搜索的路径就是</p><p>$$<br>p \rightarrow p^* \rightarrow p’<br>$$</p><h3 id="alpha-等于-1-或者无穷大的时候，都没有长程高速公路？"><a href="#alpha-等于-1-或者无穷大的时候，都没有长程高速公路？" class="headerlink" title="alpha 等于 1 或者无穷大的时候，都没有长程高速公路？"></a>alpha 等于 1 或者无穷大的时候，都没有长程高速公路？</h3><ul><li>当 $\alpha = 1$ 时（极端吝啬）<br>  高速公路死于：“过度追求最短路径，把长边当成了浪费”。<ul><li>逻辑： 当 $\alpha = 1$ 时，剪枝机制极其严格。只要 $A$ 觉得“通过 $B$ 走到 $C$ 的距离 $\le A$ 直达 $C$ 的距离”，$A$ 就会无情地把直达 $C$ 的长边剪掉。</li><li>结果： 在这种极度“抠门”的策略下，算法认为任何长跨度的边都是“冗余的、不划算的”，因为总能找到一系列小短边拼凑出一条路径。</li><li>资源状态： 节点手里的 64 个连边名额（$R$）可能都没用完。但它就是不愿意建长边，最后图里全是非常精简、互不重叠的小短边（在数学上这非常接近 Delaunay 三角网格）。</li></ul></li><li>$\alpha = \infty$ 时（极端短视）<br>  高速公路死于：“名额被短边全部占满，根本没有余力去连远方”。<ul><li>逻辑： 当 $\alpha = \infty$ 时，剪枝机制彻底关闭（不再判断抄近路的问题）。算法会严格按照绝对物理距离，连接周围的点。</li><li>结果： 因为距离中心节点最近的点，肯定是它身边的局部点。这些局部点会迅速消耗掉那 64 个连边名额（$R$）。</li><li>资源状态： 当算法扫描到远处的节点（潜在的高速公路目标）时，发现名额已经满了。</li></ul></li></ul>]]></content>
    
    
    <summary type="html">&lt;p&gt;Vector Index 相关的一些总结吧。&lt;/p&gt;</summary>
    
    
    
    
    <category term="数据库" scheme="http://www.calvinneo.com/tags/数据库/"/>
    
    <category term="数据结构" scheme="http://www.calvinneo.com/tags/数据结构/"/>
    
  </entry>
  
  <entry>
    <title>例论 TiFlash 的 HTAP 架构对排查不一致问题的影响</title>
    <link href="http://www.calvinneo.com/2026/05/06/tiflash-inconsistency-retro/"/>
    <id>http://www.calvinneo.com/2026/05/06/tiflash-inconsistency-retro/</id>
    <published>2026-05-06T15:09:06.000Z</published>
    <updated>2026-05-09T08:00:00.196Z</updated>
    
    <content type="html"><![CDATA[<p>以几年前的一个 case 为例，讨论了 TiFlash 的 HTAP 架构对排查不一致问题的影响，也讨论了如何用 AI 来减少这一类问题的调查时间。</p><a id="more"></a><h1 id="正文"><a href="#正文" class="headerlink" title="正文"></a>正文</h1><h2 id="结论"><a href="#结论" class="headerlink" title="结论"></a>结论</h2><p>这个 bug 的表象是：endless consistency 测试中，<code>insert</code> 负载下同一个 <code>start_ts</code> 对拍 TiKV 和 TiFlash，TiFlash 偶发少返回若干行，例如 <code>tikv: [35068980], tiflash: [35068960]</code>。再次用同一个 TSO 查询，结果会自动恢复一致，说明底层数据没有永久丢失，也不是被后续 snapshot 覆盖修好的持久化损坏。</p><p>最终根因不是 ReadIndex 没有推进 <code>max_ts</code>，也不是 TiKV memory lock、bypass lock、Region Split 本身。真正的问题在 DeltaMerge 的 <code>DeltaIndex</code> 复用：一个较早的读已经拿到了旧的 segment snapshot，但尚未完成 place index；另一个较晚的读先执行，把共享 <code>DeltaIndex</code> 推进到了更新的状态。这个更新后的 <code>DeltaIndex</code> 中如果包含“重复写入的同一批 row_id + version”，会把较早 snapshot 中仍应该可见的那批重复 tuple 标记为 deleted。较早的读继续执行时复用了这个过新的共享 <code>DeltaIndex</code>，于是漏读了这些行。</p><p>PR <a href="https://github.com/pingcap/tiflash/pull/9000" target="_blank" rel="noopener">#9000</a> 的修复就是围绕这个点：</p><ul><li>在 <code>DeltaTree</code> 里记录 <code>max_dup_tuple_id</code>，place insert 时记录发生重复 tuple 的最大 tuple id</li><li>clone <code>DeltaIndex</code> 时除了检查 delete range 数量不超过 snapshot，还要检查 snapshot 是否覆盖了共享 <code>DeltaIndex</code> 中所有 duplicated tuples<ul><li>如果不覆盖，就不能复用共享 <code>DeltaIndex</code>，必须为当前 snapshot 重新 place。</li></ul></li></ul><h2 id="最小化后的触发序列"><a href="#最小化后的触发序列" class="headerlink" title="最小化后的触发序列"></a>最小化后的触发序列</h2><p>issue 评论中 J-H 给出的抽象复现可以概括成：</p><ol><li>线程 A 通过 <code>resolveLocksAndReadRegionData</code> 写入一批行 <code>batch_1</code>，随后获取 segment snapshot <code>snap_a</code>。</li><li>线程 C 又写入一批和 <code>batch_1</code> 具有完全相同 row_id 和 version 的行 <code>batch_2</code>。</li><li>线程 B 获取更晚的 segment snapshot <code>snap_b</code>。</li><li>线程 B 先于线程 A 执行读流程，并更新 segment 的共享 <code>DeltaIndex</code>。</li><li>线程 B 更新 <code>DeltaIndex</code> 时，因为 row_id/version 重复，<code>batch_1</code> 在 delta tree 中被 delete 掉。</li><li>线程 A 继续使用 <code>snap_a</code> 读，但 clone/reuse 了线程 B 推进后的共享 <code>DeltaIndex</code>，导致 <code>batch_1</code> 对线程 A 不再可见，从而少读。</li></ol><p>这个错误是 transient 的：后续读通常会拿到更完整、更靠后的 snapshot，delta 覆盖了重复写入的全部 tuple，<code>DeltaIndex</code> 和 snapshot 再次匹配，所以结果自然恢复。</p><h2 id="现场现象和证据链"><a href="#现场现象和证据链" class="headerlink" title="现场现象和证据链"></a>现场现象和证据链</h2><p>初始 issue <a href="https://github.com/pingcap/tiflash/issues/8845" target="_blank" rel="noopener">#8845</a> 在 2024-03-14 提交，描述是 consistency test 中 <code>select count(*)</code> 对拍失败，TiFlash 少 20 行。Issue 被标记为 storage critical bug。</p><p>关键现象：</p><ul><li>workload 基本只有 insert，没有注入错误。</li><li>错误窗口很短，同一个事务或同一个 TSO 后续查询会收敛到正确结果。</li><li>多次现场都伴随 Region Split、Remote Read、Learner Read、lock resolve 或并发读写 DeltaMerge。</li><li>不是所有 TiFlash 节点都错，通常是某个节点的某次 TableScan 少了固定数量的行，例如 20、50、863。</li><li>检查同一时间之后的 apply snapshot，排除了“后续 snapshot 覆盖坏数据导致恢复”的解释。</li></ul><p>4 月下旬的日志把方向从事务层拉回到了 DeltaMerge：</p><ul><li>同一 region、同一 applied index 下，来自 Raft Apply 线程的写入和来自 Learner Read/resolve lock 路径的写入发生并发<br>  这其实是一个关键线索，因为它能够极大的缩小范围。实际上如果 C-N 当时没有看到这条线索，那么会在事务层上浪费更多的时间。<br>  C-N 当时提到，<strong>不妨假设事务层是有问题的</strong>，那么在这种情况下，Delta Index 也有问题。</li><li>同一批 50 条记录被两条路径写入。第一次读的 snapshot 中 <code>fully_indexed=false</code>，第二次读已经 <code>fully_indexed=true</code></li></ul><p>两次 snapshot 行数差和 delta index 行数差相差正好 50，吻合“重复 tuple 被过新的 delta index delete 掉”的模型。</p><h2 id="定位过程：难点主要在找到-DeltaIndex"><a href="#定位过程：难点主要在找到-DeltaIndex" class="headerlink" title="定位过程：难点主要在找到 DeltaIndex"></a>定位过程：难点主要在找到 DeltaIndex</h2><p>这个问题在定位到 DeltaIndex 之后，修复并不复杂，真正困难和耗时的是前面的定位：现象强烈指向事务/ReadIndex/lock/Remote Read，但最终根因藏在 DeltaMerge 的读索引复用。</p><p>早期首先确认了几个事实：</p><ul><li>TiFlash 少的是某一次 TableScan 的行数，不是聚合或 TiDB 层统计错误。把同一查询拆到各 TiFlash 节点看 <code>MPPTaskStatistics</code>，发现只有某个节点某次 scan 少了 20/50 行。</li><li>用相同 <code>start_ts</code> 后续再查会恢复，说明不是数据永久丢失，也不是 PageStorage/DeltaMerge 持久化写坏。</li><li>错误现场经常伴随 Region Split 后 epoch mismatch 触发 Remote Read，因此最早怀疑 remote read 的 key range、region split 处理、apply snapshot 覆盖等路径。</li><li>检查错误时间点之后的 apply snapshot，发现没有发生能解释“恢复正确”的 snapshot 覆盖行为，于是排除了 apply snapshot 覆盖坏数据。<br>  这个判断是很重要的，因为在检查 raft 路径导致的不一致问题的时候，需要首先区分是否是 apply snapshot 导致的。对应的后续调查方案是不一样的。</li></ul><p>接着排查转向事务可见性。C-N 在 issue 第一条评论里提出过一个很合理的怀疑：</p><ul><li><a href="https://github.com/pingcap/tiflash/pull/3971" target="_blank" rel="noopener">#3971</a> 引入了同 region 的历史 ReadIndex 结果复用</li><li>如果两个事务互不可见，<code>start_ts</code> 和 commit record 在 Raft log 中的顺序不一定一致，那么较小 TSO 复用较大 TSO 的 read index 可能读不到后面的 commit record<br>  这个假设解释力很强，因为现象正好是“TiFlash 少读已提交数据”。</li><li>但后续 J-H 指出，Async Commit 的 <code>max_ts</code> 推进理论上应该防止这个问题，所以它不能直接作为根因。</li></ul><p>之后又集中排查了 <code>max_ts</code>、memory lock 和 bypass lock：</p><ul><li>TiFlash 的 read index 路径一度被怀疑没有真正通过 TiKV 的 <code>ReadIndexObserver</code> 推进 <code>max_ts</code>，因为旧的 <code>read_index</code> RPC 已经不再使用，而 TiFlash 看起来发送的是 <code>RaftCmdRequest{cmd_type=ReadIndex}</code>。<br>  后来通过继续跟 TiFlash proxy 到 TiKV leader 的交互确认，TiFlash 虽然内部使用 <code>RaftCmdRequest</code>，但真正和 TiKV 交互仍走 <code>MsgReadIndex</code> raft message，路径是合理的。</li><li>使用 TiKV 侧临时日志确认：TiFlash Proxy 发出的 <code>MsgReadIndex</code> 带上了目标 <code>start_ts</code>；TiKV 收到后确实打印了 <code>advance max_ts to ...</code>，也返回了对应 read index。这排除了“完全没有推进 <code>max_ts</code>”的简单解释。</li><li>memory lock 也被排除<br>  因为：多个复现场景中错误附近没有足够的 memlock 事件；有些焦点 region 的 <code>bypass_locks</code> 为空；TiFlash 遇到 lock 后触发 Remote Read、resolve lock、重试的行为在日志上能解释，但不能解释最终少行。</li><li>bypass lock 也被排除<br>  因为：相关日志显示读事务并没有依赖异常的 bypass lock 路径，且 lock 的 <code>min_commit_ts</code>/<code>commit_ts</code> 关系不能完整解释“同一 TSO 后续恢复”的现象。</li></ul><p>这个阶段最迷惑的是“矛盾日志”：</p><ol><li>TiKV 已经 advance <code>max_ts</code> 并返回 read index，例如 region 459 返回到 313679。</li><li>但 TiFlash 随后在 apply 313680 时仍看到 <code>commit_ts &lt; read_tso</code> 的记录。</li></ol><p>这看起来像 follower read 与 Async Commit 的线性一致性问题。后续还去咨询 TiKV 侧，分析 async commit、read through lock、<code>min_commit_ts</code> 推进规则。这个方向耗时很大，因为它确实和一致性语义相关，而且日志表面上支持。</p><p>后续这个问题进入了僵局。最终 C-N 发现了下面的问题：</p><blockquote><p>转⽽考虑，⽆论是否承认 max_ts 有问题，⾄少确认已经 apply 到了 79 这个 raftlog，那么：</p><ol><li>要么能看到 lock</li><li>要么能看到 commit<br>不应该出现既没有看到 lock ⼜没有看到 commit 的情况。因此准备转⽽调查 resolvelock 和 raft command 两个地⽅的⾏转列的过程。</li></ol></blockquote><p>这是整个问题解决的关键，因为它揭示了在经过了那一团浆糊一样的事务问题之后，无论这时候的数据是否已经有问题，那么后续的处理也是有问题的。</p><p>C-N 把两次读同一个 segment 的信息做了对比：</p><ul><li>第一次读拿到的 snapshot：<code>fully_indexed=false</code>，snapshot 中的 stable/persisted/mem rows 总数较少。</li><li>第二次读拿到的 snapshot：<code>fully_indexed=true</code>，snapshot 行数更多，<code>DeltaIndex</code> 也更靠后。</li><li>两次 snapshot 行数差是 4860，两次 delta index placed rows 差是 4810，差值正好 50。</li><li>同时 Learner Read 线程和 Raft Apply 线程对同一 region、同一 applied index 写入了同一批 50 条记录，版本和 handles 完全吻合。</li></ul><p>这组证据把问题从“为什么读不到已经 commit 的 MVCC 数据”改写成“为什么旧 snapshot 会使用包含额外重复 tuple 删除信息的过新 DeltaIndex”。随后 JHL 在 PR #9000 中抽象出单测：</p><ul><li>线程 A 先拿旧 snapshot，线程 B 先读并推进 shared delta index</li><li>然后线程 A 复用这个 shared delta index 时少读。</li></ul><p>PR 评论里最小测试曾复现 <code>count1 = 118, count2 = 128</code>，这直接证明了问题在 DeltaIndex 和 snapshot 的匹配关系，而不是事务层。</p><h2 id="为什么这么难查"><a href="#为什么这么难查" class="headerlink" title="为什么这么难查"></a>为什么这么难查</h2><ol><li>症状像事务一致性问题，但根因在存储读索引复用。TiFlash 少读的行对应的 <code>commit_ts</code> 小于读 TSO，且现场经常出现 ReadIndex、Async Commit、memory lock、bypass lock、Remote Read、Region Split，因此很自然会先怀疑 <code>max_ts</code> 推进、lock resolve 或 ReadIndex 复用。</li><li>问题会自动恢复，容易误导排查。相同 TSO 之后再查是正确的，说明数据既没有永久丢也没有损坏；这排除了很多常规方向，但也让现场窗口很短，必须在错误发生时保留 segment snapshot、DeltaIndex、KVStore、日志和 region 信息。</li><li>复现条件苛刻。它需要高并发读、Remote Read/resolve lock 触发的写入、Raft Apply 写入、相同 row_id/version 的重复 tuple、旧 snapshot 和新共享 DeltaIndex 交错复用。早期本地集群和 IDC 集群很难稳定复现，后来通过调小 region 大小、提高 split 频率、打开 failpoint 增加 remote read 才提高概率。</li><li>中间出现了多个合理但非最终的假设。PR <a href="https://github.com/pingcap/tiflash/pull/3971" target="_blank" rel="noopener">#3971</a> 引入的 batch/async read-index 复用逻辑一度被怀疑；<a href="https://github.com/pingcap/tiflash/pull/8873" target="_blank" rel="noopener">#8873</a> 增强了 ReadIndexWorker 日志；<a href="https://github.com/pingcap/tiflash/pull/8874" target="_blank" rel="noopener">#8874</a> 增加写入 version 和 segment snapshot rows 日志；<a href="https://github.com/pingcap/tiflash/pull/8928" target="_blank" rel="noopener">#8928</a> 用来检查 async task 测试/日志路径。这些帮助排除方向，但不是最终修复。</li><li>TiKV/TiFlash 日志存在时钟漂移和跨组件链路。文档里曾用 TiKV 加日志确认 TiFlash Proxy 确实发了 <code>MsgReadIndex</code>，TiKV 也 advance <code>max_ts</code> 并返回 read index；但 TiFlash 随后仍看到看似 <code>commit_ts &lt; read_tso</code> 的写入。这让问题一度看起来像 Async Commit 与 follower read 的线性一致性问题。后续才确认这不是最终矛盾，而是并发写入和 DeltaIndex 复用造成的读视图错配。</li></ol><h2 id="从-TiFlash-架构看，为什么一致性问题更难查"><a href="#从-TiFlash-架构看，为什么一致性问题更难查" class="headerlink" title="从 TiFlash 架构看，为什么一致性问题更难查"></a>从 TiFlash 架构看，为什么一致性问题更难查</h2><p>TiFlash 的 HTAP 架构选择是“TiKV 行存主副本 + TiFlash 列存 learner 副本”。官方文档中也说明，TiFlash columnar replica 是通过 Raft Learner 异步复制得到的：<a href="https://docs.pingcap.com/tidb/stable/tiflash-overview/" target="_blank" rel="noopener">TiFlash Overview</a>；VLDB 论文 <a href="https://vldb.org/pvldb/vol13/p3072-huang.pdf" target="_blank" rel="noopener">TiDB: A Raft-based HTAP Database</a> 也描述了 TiFlash learner 接收 Raft log，并把 row-format tuple 转成 columnar representation。这个架构带来了很好的 HTAP 隔离和列存性能，但一致性排查天然更复杂。</p><ol><li>TiFlash 不是事务提交路径上的 voting replica，而是 learner columnar replica。写入先在 TiKV/Raft 事务语义中成立，然后 TiFlash 通过 Raft log apply、row-to-column decode、DeltaMerge 写入、segment snapshot、DeltaIndex 等步骤把数据转成可分析查询的列存视图。因此一个读结果不一致，可能发生在事务层、Raft learner apply、proxy 交互、行转列、DeltaMerge 存储视图、查询执行任意一层。相比单一存储引擎，怀疑面更宽。</li><li>TiFlash 的“读到某个 TSO”不是简单读一个本地 MVCC store。它需要 ReadIndex 保证 learner 至少 apply 到足够新的 Raft index，还要处理 Async Commit lock、<code>max_ts</code>/<code>min_commit_ts</code>、read through lock、bypass lock、resolve lock、Remote Read 重试。也就是说，读可见性由 TiKV 事务协议、Raft read index、TiFlash learner 状态和本地 DeltaMerge snapshot 共同决定。任何一层日志单独看都可能“合理”，但组合起来才暴露矛盾。</li><li>Region Split 和 Remote Read 会把一个逻辑 table scan 拆成跨 region、跨 TiFlash 节点、跨 epoch 的多个子读。Issue #8845 的现场多次出现 split 后 epoch mismatch，随后触发 Remote Read；Remote Read 又可能在另一个 TiFlash 节点上以 Coprocessor 请求形式读同一个 region。这样一来，同一个 SQL 的错误可能只出现在某个 region 的某个 remote cop task 上，而其他 TiFlash 节点和后续查询都正确。定位时必须把 SQL、MPP task、region epoch、remote target、read index、segment 读任务全部串起来。</li><li>TiFlash 本地列存不是 Raft KV 的直接镜像，而是 DeltaMerge 的多层读视图。一次读会拿 segment snapshot，再决定是否复用 shared <code>DeltaIndex</code>、是否需要 <code>ensurePlace</code>、是否 <code>fully_indexed</code>。这类内部优化通常不改变持久化数据，只影响某个瞬间的读视图，所以 bug 表现为“瞬时少读，后续恢复”。这种问题不会像数据损坏那样留下稳定现场，也不会像事务协议错误那样一定能从 TiKV 日志直接解释。</li><li>TiFlash 为了性能引入了多处跨请求复用：ReadIndex 结果复用、shared DeltaIndex 复用、batch read index、remote read 重试、snapshot 复用/推进。这些优化单独看都有正确性条件，但一致性 bug 往往出现在“两个正确优化的边界交错”上。#8845 就是旧 snapshot 和过新的 shared <code>DeltaIndex</code> 在 duplicated tuple 场景下组合出了错误读视图。</li></ol><p>和其他 HTAP 实现相比，这个复杂度有 TiFlash 架构自身的特点：</p><ul><li>SingleStore 官方文档强调它可以在一个系统中结合 rowstore 和 columnstore，并在单个查询里合并实时和历史数据：<a href="https://docs.singlestore.com/db/v9.0/introduction/how-singlestore-works/high-performance-for-oltp-and-olap-workloads/" target="_blank" rel="noopener">High-Performance for OLTP and OLAP Workloads</a>。它也有分布式和存储格式复杂性，但通常不是“TiKV 行存主副本 + TiFlash Raft learner 列存副本”这种跨进程、跨引擎复制后的读视图问题。</li><li>CockroachDB 更偏向单一分布式 KV/MVCC 存储层，上层有向量化/列式执行来加速分析型查询：<a href="https://www.cockroachlabs.com/docs/stable/architecture/overview" target="_blank" rel="noopener">Architecture Overview</a>。这类架构的难点更多集中在事务、租约、range、closed timestamp 等同一存储系统内的一致性，而不是额外列存 learner 副本与行存主副本之间的视图对齐。</li><li>OceanBase 官方 HTAP 介绍强调在同一个分布式数据库内直接承载交易和分析：<a href="https://oceanbase.github.io/docs/user_manual/operation_and_maintenance/en-US/scenario_best_practices/chapter_03_htap/introduction" target="_blank" rel="noopener">OceanBase HTAP introduction</a>。它同样有分布式事务和分析执行复杂性，但 TiFlash 这种“主行存 + 异步列存副本 + Raft learner + 行转列 DeltaMerge”的链路，给排查额外引入了副本同步点和列存视图构建点。</li></ul><p>所以 TiFlash 的一致性问题难查，并不是因为某个模块特别脆弱，而是因为它把事务系统、Raft 复制、异步列存副本、MPP/Remote Read、DeltaMerge 本地读优化组合在一起。问题的真实根因可能在任意一层，但表象往往会穿过多层后才被 SQL 对拍发现。#8845 正是这种架构复杂性的典型案例：外观看起来像事务/ReadIndex 问题，实际是列存读视图中 shared DeltaIndex 和 snapshot 的代际错配。</p><h2 id="关联-PR-和作用"><a href="#关联-PR-和作用" class="headerlink" title="关联 PR 和作用"></a>关联 PR 和作用</h2><ul><li><a href="https://github.com/pingcap/tiflash/pull/9000" target="_blank" rel="noopener">#9000</a>：最终修复。核心是阻止旧 snapshot 复用包含其未覆盖 duplicated tuples 的过新共享 <code>DeltaIndex</code>，并补充单测 <code>DupHandleVersionAndDeltaIndexAdvancedThanSnapshot</code>、<code>ReadWithMoreAdvacedDeltaIndex2</code> 等。</li><li><a href="https://github.com/pingcap/tiflash/pull/8873" target="_blank" rel="noopener">#8873</a>：排查期间改进 ReadIndexWorker 代码和日志，记录 read index 复用等信息。</li><li><a href="https://github.com/pingcap/tiflash/pull/8874" target="_blank" rel="noopener">#8874</a>：增加可选的 record version 日志和 segment snapshot rows 日志，用于确认写入版本、行数和 snapshot 关系。</li><li><a href="https://github.com/pingcap/tiflash/pull/8928" target="_blank" rel="noopener">#8928</a>：排查 remote read / async task 相关现象时用于检查测试路径，不是根因修复。</li><li><a href="https://github.com/pingcap/tiflash/pull/3971" target="_blank" rel="noopener">#3971</a>：历史上引入高并发下按 start-ts batch/reuse read-index 的机制，一度被怀疑会导致旧 TSO 复用过小 read index；最终由 <code>max_ts</code> 逻辑和后续证据排除为主因。</li></ul><h2 id="如果用-AI-辅助调查，能加速哪里"><a href="#如果用-AI-辅助调查，能加速哪里" class="headerlink" title="如果用 AI 辅助调查，能加速哪里"></a>如果用 AI 辅助调查，能加速哪里</h2><p>这类问题里，AI 最有价值的地方不是直接猜根因。早期现象确实很像 ReadIndex、Async Commit、lock 或 Remote Read 问题，AI 如果只根据表象下结论，也很可能走同样的弯路。真正能加速的是把大量日志、代码路径、假设和反证组织起来，让调查更快收敛到“哪个假设还站得住”。</p><ol><li>日志归并和时间线重建<br> 这个 bug 的证据分散在 endless 报错、TiFlash MPPTask、LearnerReadWorker、RemoteRequest、DeltaMergeStore、Segment、Proxy、TiKV raftstore 日志里。<br> AI 可以围绕同一个 <code>start_ts</code>、<code>region_id</code>、<code>applied_index</code>、<code>row_id/version</code> 自动抽取事件，重建“split -&gt; remote read -&gt; read index -&gt; resolve lock -&gt; raft apply -&gt; segment read”的时间线。</li><li>维护假设和排除矩阵<br> 排查过程中出现过 remote read key range、Region Split、apply snapshot、ReadIndex 复用、<code>max_ts</code> 未推进、memory lock、bypass lock、DeltaIndex 等多个假设。<br> AI 的作用是能够快速地去探明一个可能的原因是否是真的 root cause，从而去简化上下文。这是因为随着查询链条的深入，也引入了多个分叉，链条之间的因果就不是那么牢靠。从一个角度能解释的通，但是从另一个角度可能这个原因就解释不通。<br> 更重要的是，它可以提醒“<code>fully_indexed=false</code> + 后续 shared delta index 被推进”本身就是存储读视图风险点，避免在事务层钻牛角尖，从而更早转回 DeltaMerge。</li><li>生成更精准的 instrumentation<br> 排查中实际合入了 #8873 和 #8874 来增强日志。AI 可以基于当前假设建议更有针对性的打点，这能减少“先广泛加日志再人工筛”的迭代成本。</li><li>从现场日志反推出确定性单测<br> 最终 #9000 的测试本质上是把线上交错压缩成一个可控序列：线程 A 先拿旧 snapshot，线程 B 先读并推进 shared delta index，然后线程 A 再用旧 snapshot 读。AI 很适合根据日志里的 happens-before 关系生成这种 test skeleton，帮助把偶发线上问题变成稳定单测。</li><li>跨组件语义校验<br> <code>ReadIndexObserver</code>、<code>MsgReadIndex</code>、<code>RaftCmdRequest</code>、Async Commit、<code>max_ts</code>、<code>min_commit_ts</code>、read through lock、bypass lock 这些概念很容易混在一起。AI 可以把设计文档、代码和日志放在一起核对：当前路径到底是否推进了 <code>max_ts</code>，哪个 message 类型生效，<code>bypass_locks=[]</code> 能排除什么，<code>commit_ts &lt; read_ts</code> 的日志是否一定表示事务层错误。这个能力能帮助更快识别“看似矛盾但其实不是根因”的证据。<br> 这能够减少查问题的时候，因为涉及到不同组件，不同人之间的协调产生的损耗。</li></ol>]]></content>
    
    
    <summary type="html">&lt;p&gt;以几年前的一个 case 为例，讨论了 TiFlash 的 HTAP 架构对排查不一致问题的影响，也讨论了如何用 AI 来减少这一类问题的调查时间。&lt;/p&gt;</summary>
    
    
    
    
    <category term="数据库" scheme="http://www.calvinneo.com/tags/数据库/"/>
    
  </entry>
  
  <entry>
    <title>What&#39;s left for the engineers in the AI era</title>
    <link href="http://www.calvinneo.com/2026/03/24/new-engineer/"/>
    <id>http://www.calvinneo.com/2026/03/24/new-engineer/</id>
    <published>2026-03-24T15:20:37.000Z</published>
    <updated>2026-03-24T05:17:14.103Z</updated>
    
    <content type="html"><![CDATA[<blockquote><p>这是一篇简单直接的文章（或者被认为是提纲），目的是提出价值判断、提出关键问题。我刻意避免引用例子，或者论述逻辑来佐证观点，也刻意避免提出解决方案，因为我认为这一部分工作已经被 AI 所取代。</p></blockquote><p>本文主旨在于探讨在 AI 时代，一个工程师还能够输出什么样的价值。<br>《空中浩劫(ACI)》系列是理解工程思想很好的学习案例，而计算机系统和航空产业又有很多的共同点。下面几点尤其值得关注：<br>1.所有的黑天鹅都是灰犀牛<br>2.本质上都不相信人和机器，对环境保持最低限度的假设<br>3.计算机（AI、自动驾驶）的参与度都很高</p><a id="more"></a><h1 id="管控风险"><a href="#管控风险" class="headerlink" title="管控风险"></a>管控风险</h1><blockquote><p>瑞士奶酪模型（Swiss Cheese Model）：在复杂的工程系统中，灾难极少源于单一故障，而是多层防御体系中的隐患恰好‘对齐’所致。</p></blockquote><p>从单个模块的视角观察，一些缺陷的影响并不显著，但是在系统中则会成为致命风险中的一环。在实践中，这样的缺陷可能还会被放大，呈现“蝴蝶效应”。一个超出 SOP 的行为可能产生远超自己预期的结果。<br>这个模型没有强调的一点是，在计算机或者民航这样的高强度运行的系统中，一切有可能发生的问题最终一定会发生。因此，管控风险不能功利主义地乘上概率，而是真的要把那微小的 corner case 当做正常情况来处理。<br>我认为一个系统的复杂度和风险无论经过怎么样的封装或者 trade off，都是不能最终被消除的。既然风险是正常情况，管控和确认风险将始终是每个工程师的任务。</p><h1 id="和机器相处"><a href="#和机器相处" class="headerlink" title="和机器相处"></a>和机器相处</h1><h2 id="人机接管边界"><a href="#人机接管边界" class="headerlink" title="人机接管边界"></a>人机接管边界</h2><p>控制权在人与机器之间切换的那个“边界时刻”，往往最容易引发问题。此类问题的特征是机器或者人类都可以独立完成任务，但是当两者合作时就产生了交接过程中的掉棒，或者合作过程中的冲突。<br>这种问题本质上是在几万年的进化中，人和人之间已经形成了诸多共识；在机器设计的过程中，各个模块间指定了 protocol，并通过测试来保证正确性。但是人和机器的交互之间并没有形成相互的理解，也没有信任。</p><h2 id="从写认知到读认知"><a href="#从写认知到读认知" class="headerlink" title="从写认知到读认知"></a>从写认知到读认知</h2><p>读优化和写优化是数据库系统中常常要思考的问题，对于人脑也是如此。从我的观察来看，人脑是一个写优化的系统：布道远比学习要容易，输出自己永远比理解他人要容易。</p><h2 id="统计学与偏见"><a href="#统计学与偏见" class="headerlink" title="统计学与偏见"></a>统计学与偏见</h2><blockquote><p>人类的大脑是一台出色的“模式识别机”，但绝对不是一台合格的“统计计算机”。 —— 丹尼尔·卡尼曼</p></blockquote><p>在我的文章<a href="/2021/05/15/probability-problems/">《概率论中的几个有趣问题》</a> 中论述了一些“反直觉”的统计问题。<br>但更本质的是，无论是“厌恶”还是“偏见”，人类更愿意基于经验去得到一个非 0 即 1、非黑即白的结论，这是厌恶非确定的本能。关于这个问题我在 <a href="/2025/02/09/logical-fallacies/">《形式谬误和非形式谬误》</a> 一文中也进行了详细的论述。<br>我认为 AI 的出现会加剧这样的问题，因为 AI 迎合了人类这样的性格弱点。</p><h2 id="从提出问题到构建价值"><a href="#从提出问题到构建价值" class="headerlink" title="从提出问题到构建价值"></a>从提出问题到构建价值</h2><blockquote><p>Code is cheap, show me the talk.</p></blockquote><p>在 AI 年代，这句话指出了提出问题比解决问题更加困难也更加有价值这个事实。因此本文的写作中，根本也没有提出解决方案，毕竟有太多关于它们的讨论了。</p><p>但随着 AI 将能力边界扩展到了“主动式智能”领域，它们是有能力提出一个好问题，从而推动进化和进步的。所以问题留给了人类，当 AI 澎湃的生产力剥夺了人的利他性，那么人类的最终价值是什么？</p><p>我想这个答案应该很简单，当人的所有属性都被剥夺之后，人的价值就不再依赖任何的属性和定位，人的价值就在于他是人。我希望 AI 能够引导一个伟大的社会变革，但留给人类最应该做的是为 AI 的发展方向提供一个优化目标，也就是构建价值。</p><h1 id="比失败更糟糕的是“局部成功”"><a href="#比失败更糟糕的是“局部成功”" class="headerlink" title="比失败更糟糕的是“局部成功”"></a>比失败更糟糕的是“局部成功”</h1><p>最后想再多说一句，现在是一个人人 demo 的年代，”Done” 的门槛已经越来越低，Done is no longer better than perfect。<br>那么什么是真正的门槛呢？我想 BERT 本身就是一个很好的反例，它的失败恰恰可以归功于它的成功。也许我们每次在设计的时候，真的需要多问自己一句，这个架构是不是真的就止步于此了？</p>]]></content>
    
    
    <summary type="html">&lt;blockquote&gt;
&lt;p&gt;这是一篇简单直接的文章（或者被认为是提纲），目的是提出价值判断、提出关键问题。我刻意避免引用例子，或者论述逻辑来佐证观点，也刻意避免提出解决方案，因为我认为这一部分工作已经被 AI 所取代。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;本文主旨在于探讨在 AI 时代，一个工程师还能够输出什么样的价值。&lt;br&gt;《空中浩劫(ACI)》系列是理解工程思想很好的学习案例，而计算机系统和航空产业又有很多的共同点。下面几点尤其值得关注：&lt;br&gt;1.所有的黑天鹅都是灰犀牛&lt;br&gt;2.本质上都不相信人和机器，对环境保持最低限度的假设&lt;br&gt;3.计算机（AI、自动驾驶）的参与度都很高&lt;/p&gt;</summary>
    
    
    
    
    <category term="Articles" scheme="http://www.calvinneo.com/tags/Articles/"/>
    
  </entry>
  
  <entry>
    <title>呼和浩特和大同游记</title>
    <link href="http://www.calvinneo.com/2026/02/24/meet-in-hohhot-datong/"/>
    <id>http://www.calvinneo.com/2026/02/24/meet-in-hohhot-datong/</id>
    <published>2026-02-23T17:20:33.000Z</published>
    <updated>2026-02-25T14:28:15.425Z</updated>
    
    <content type="html"><![CDATA[<p>过年期间去了呼和浩特和大同。这是首个依照 codex 做的旅游规划玩的活动。</p><a id="more"></a><h1 id="D0"><a href="#D0" class="headerlink" title="D0"></a>D0</h1><p>我的行程在 <a href="https://github.com/CalvinNeo/CalvinSchedule" target="_blank" rel="noopener">https://github.com/CalvinNeo/CalvinSchedule</a> 中。</p><h1 id="D1-初一"><a href="#D1-初一" class="headerlink" title="D1 初一"></a>D1 初一</h1><p>因为我对象年三十值班，所以我们是定了初一下午的飞机飞呼和浩特。为什么去呼和浩特是因为去长春的飞机票买晚了，所以在选择从大连出发玩东北，还是从呼和浩特出发玩呼和浩特和大同之间的权衡。</p><p>事实证明，呼和浩特是一个挺好的地方，首先它去大同比太原还要方便，其次，它的机场到高铁站很方便，所以我们直接定一个高铁站旁边的酒店就非常舒服了。不过据说呼和浩特的新机场要启用了，因此后面它就没太原爽了。</p><p>因为我们值机比较靠前，所以下飞机是比较快的，然后就直往地铁站跑，赶上了倒数第二班地铁。事实证明坐地铁还是对的，因为后面我们点了个鼎鼎眼镜烧烤，发现等了好久都没有骑手接单，最后还是加钱人家才送的。</p><h1 id="D2-初二"><a href="#D2-初二" class="headerlink" title="D2 初二"></a>D2 初二</h1><p>今天起来还是很感冒，还是流鼻涕。</p><p>早上 8 点，我们的小团才接我。这也是因为我们住在呼市最东边的缘故，所以不用起那么早。车上除了我全是女的，所以我就坐在副驾驶了。这个副驾驶的头枕非常靠后，所以我睡起来很不方便。</p><p>第一站是辉腾草原上面的马场。这个马场除了骑马和卡丁车（实际上没人玩）啥都没有，所以尽管我们没有定骑马的套餐，所以逼到最后还是只能骑马。那边报价 140，而淘宝只要加 120，所以我们用淘宝价还价骑了马，然后又加了 120 骑了快马。<br>大概流程就是先上一匹小马，然后几匹马一起被牵着走到跑马场。到那边老板就问要不要骑快马，如果骑，就换到大马身上。然后老板就会同时拉着你的缰绳和自己的缰绳把马跑起来，嘴上还嘚嘚嘚嘚的。一开始马是小跑，这个时候你得用腿用力夹住马的肚子。不过后面马就会撒开来快跑了，这个时候，就是颠屁股了，感觉整个人都要散架，必须要拉着马鞍才会稳一点，然后就跑完了。</p><p>总的来讲感觉价格偏贵。体验上的话，快马还是可以的，不过时间也很短。当然，再长一点，我呛风也受不了了。然后这地方的旱厕也是堪称一绝，里面的屎冻成了棍子，我也是第一次见。导游说你就路边上尿吧，我寻思这么大的风，不吹到身上么。</p><p>然后就是去吃饭，开车到了右翼中旗县城里面，就开了那么几家店。我们选了一家，我对象点了个羊杂，点了个驼饼。我吃了下，感觉羊杂还挺香的，驼饼感觉就是普通的肉饼吧，然后查了下，说是骆驼肉。</p><p>吃完饭，就去火山了，这个也是要开一大段路的。那一块其实有很多火山，有的火山形状像草帽山，我把它叫土帽山。不过我们实际去逛的那个叫南炼丹炉，是一个平顶的火山。相比我们在冰岛看到的，这个火山确实有点火山的感觉。</p><p>从火山回来，就是长达三个小时的回程了。我们让司机帮我们送到宽巷子，这样就可以直接吃东西了。下车就能看到杨老大焙子店，结果没开门。旁边的星月排满了队，所以我们就去清和园了。这边买芝士奶饼好多都是几十个买的，我们只买了两个感觉很亏。然后我们就去珠萨拉买了几个酸奶糕，是冰着的，感觉挺好吃。</p><p>吃完就准备打车去泽成冰煮羊了，这个店在附近有两家。我决定去万象城那一家，因为那边等的时候至少可以逛一逛。事实上感觉也是对的，因为那天晚上我感冒贼难受，加上又很干，嗓子不舒服。排队也是一百多号，特别渴，所以想买个奶或者沙棘汁喝喝，找到一个牧野晨曦奶茶店，说是要等一个多小时，立马吓退。</p><p>反正最后总算是进去了，这个冰煮羊必须要至少点一斤的羊肉或者羊排。</p><h1 id="D3-初三"><a href="#D3-初三" class="headerlink" title="D3 初三"></a>D3 初三</h1><p>今天需要早起去大同。因为我们在火车站旁边住，所以提前一个小时起床绰绰有余了。内蒙古的火车会说什么内蒙古好羊肉，内蒙古羊肉好，非常洗脑。反正一路上也是比较困，睡睡醒醒的。<br>从一路上看，内蒙古和山西确实不太一样，首先，内蒙古真的有很多风车。然后，内蒙古感觉是草原的感觉，是有黄草的，但山西的话会更有黄土高原的感觉。</p><p>下了大同站，想要拉屎。我对象不在车上拉，结果下了车就要排队。其实始发站的火车，我一般是喜欢在火车上拉屎的，因为一般都很干净。拉完屎还有五分钟，就跑到直通车那里，准备去云冈石窟。上了车，开个大概有一个多小时才到，真的是非常非常堵了。</p><p>云冈石窟人非常多，主要体现在：首先，它景区检票口开了好几个，但居然都要排队。其次，是它的讲解也要排队，我们想想还是旅途随身听算了。反正进去之后，就绕了一圈，看了一下它的一个寺庙的前中后殿，然后过了桥，就是石窟的主体。</p><p>因为我之前在车上已经预习过了，所以我大概知道这些石窟大概分为几个系列，然后哪些是比较精华的。反正一开始进去的第一窟和第二窟都是比较惨烈的，因为它们的开口很小，所以基本人只能站在石阶上往里面伸着头看，我似乎就看到几个石柱子，感觉没啥意思。</p><p>第五窟和第六窟是一起的，实际上我们排最长的也是第六窟，因为第五窟当时已经维修了。保安说要排一个多小时，但实际排了四十几分钟就进去了。这个窟实际上是有前窟和后窟的，云冈石窟大部分也都是这个式样。并且相比于莫高窟或者龙门石窟，云冈石窟的颜色没怎么掉，所以看起来更鲜艳，据说这个可能是因为之前有人补过颜色吧。</p><p>在排第 6 窟之前，还看到旁边有一个可以往上爬的地方，当时也没有注意是啥。回来的时候，我们找从上面下来的人问了下，说也是一些小石窟，所以就没有再上去了。后面到那个院史馆看了下，说上面好像是有个什么寺的遗址，我觉得也是挺神奇的。</p><p>9/10 两个窟或者是 7/8 两个窟好像是一对的，就是它们的构造都很相似。据说是什么太后要和皇帝平起平坐，所以搞了两个相同的。</p><p>11/12/13 这几个窟是连在一起的，也就是有名的音乐窟。这几个窟人不是很多，感觉是因为窟比较大，所以能够流水线进出。</p><p>14 窟看不出来是啥。15 窟是那个万佛洞，里面雕的全是佛像，看起来有点密恐。</p><p>16-20 就是著名的昙曜五窟了。</p><p>看完 20 窟，再往前走就是西部窟群，里面的东西就比较挫了。</p><p>旅途随身听上看到有个云冈石窟博物馆，加上之前听到说有什么东西被抠出来放到了博物馆里面，我就想去看看，结果这博物馆就没开。我记得之前好像也是哪个景区里面的博物馆也不开的，感觉还是比较遗憾的。</p><p>出去的路也是比较奇葩的，因为这个景区里面有一堆美术馆，但是都关门了，最离谱的是还有一个侏罗纪断层的展示，上面放了一堆恐龙模型，也不知道是在干嘛。</p><p>琥珀知道我们到了大同，就想跟我们面面基，一开始提议是去古城看灯展。所以我们从云冈石窟出来，就买了直通车的票，准备回古城，和琥珀约一下。这个直通车体验是真的差，首先，车里面暖气开的热的像桑拿一样。然后，路上又贼堵，关键是这车非要沿着堵麻了的平城街开到和阳门那里下客。我能理解上客得在那，但是既然那么堵，为什么不能在古城北门先让我们下一下呢？本来我们是准备坐这个车先到宾馆放一下东西再进古城的，但是这一下子开了快两个小时，感觉再回去就来不及排队吃饭了，所以我们就在古城下车了。一进古城就发现东门排着队，我们觉着应该是上城墙准备去看花灯的，所以也果断不去看灯展了。</p><p>琥珀显然对大同的人流没有预期，搞了半天说要吃紫泥，结果我们去古城紫泥拿了个号，发现要等 290+ 桌。不过我们倒是在古城的凯鸽也排了个号，只有 29。不过考虑到它一直不叫号，并且古城也没啥可以逛的（人特别多），所以我们就准备出去找点东西吃。经过一系列的电话咨询，我们发现紫泥在南环路的一家店还是可以取号的，所以就骑自行车过去。</p><p>骑车过去的路也是比较奇葩，主要是出了古城城门需要往右拐，结果交警让我们走上面走，结果骑着骑着就骑到了永泰门广场上了。这个广场是被拦着的，自行车没法进，我们也下不去。结果我们只能闯过一片烂泥地强行进去，然后又在前面的栅栏的地方，把自行车搬了出去。骑到紫泥那里，它家在三楼，但是只有直梯上去，感觉挺麻烦的。上去之后果然全是人，反正是取了个号，然后打算先去找点东西垫垫肚子。先骑车去旁边的和笙财，点了个沙棘冰淇淋，这个冰淇淋是真好吃。然后发现旁边就是老柴削面的总店，但是我对象还是想吃喜晋道，所以就骑车去旁边的喜晋道，中途路过大同一中，感觉这个学校真的是富丽堂皇啊。进去喜晋道，他家是一个非常大的门面，装修非常漂亮，但是一进去，就说没位置了，并且都不发号了。于是就灰溜溜排老柴削面。再过去，就发现老柴削面外面都全是人了。因为反正没事做，就进去点了个最基础的猪肉面，后面就是漫长的等待。我对象要找个座位，我是受不了，因为里面又热又闷又吵又挤，感觉就像是浴室里面一样。然后不断还有人端着碗要你让，或者叫着“臭油”把一堆泔水一样的东西拿到外面倒掉。我一直在外面等，发现有人把盘子端到旁边的黄焖鸡的店面里面吃，黄焖鸡的老板也是日了狗了。这家店外面还有叫什么老柴门口烧烤，也有人点，不过我搜了下，说这烧烤贼一般，就算了。</p><p>等老柴削面的过程也是很累，我们应该是 834 号，点完单的时候刚叫到 78x 号。然后一堆人就在那个打面的地方排着听叫号。这里面坑的是一个号可能点很多碗面，比如一个东北大哥一个号点了七八碗面还有一堆小菜，前后端了大概有五六次。相比之下，我们这一碗面就显得很亏。反正最后还是等到了面，吃起来，感觉挺一般的，有点类似于之前在太原全季早餐吃的刀削面。也许有那么一点更劲道，或者汤底更香吧，但可能是纯感觉，唯一可以确定的是这汤底是确实齁咸。</p><p>吃完了老柴削面，紫泥差不多也快到了，于是就走路过去。上去之后，发现大厅等得全是人，然后还有人源源不断上来，然后服务员说还要再等两个多小时。我们好像是 179 号，反正就是硬等了。有一个大哥盯着监控，看哪一桌走了，就说我就是下一个号，你给我就安排那里吧，感觉是饿坏了。很快到我们了，然后我们前面的号问我们要不要，自己当时排了两个号，我说我就是下一桌了。</p><h1 id="D4-初四"><a href="#D4-初四" class="headerlink" title="D4 初四"></a>D4 初四</h1><p>今天继续是早起的一天，我们需要去恒山景区。从酒店到南站有一定距离，还是扫了个车骑了过去。然后，发现百度导航真的是糟糕，直通车明明是车站的另一端，它给标错了。总之赶到了直通车那，说恒山的车堵在高架上，可能要晚点。然后我就去上了个厕所，果然是上厕所定律了，上到一半，车就来了，结果我赶快跑了回去。在车上迷迷糊糊睡到恒山，到了那个游客中心附近又开始堵车了。总之到了下面，就要坐摆渡车，我也看到了之前在小红书上看到的排队标志，所幸今天的人没有昨天多，不过悬空寺方向还是挺长的，所以我们决定先去爬恒山了。</p><p>去恒山的车会经过悬空寺，在经过一个隧道之前，能看到悬空寺，并且这是一个很好的从上往下看的机位，建议不要错过，因为返程的时候，需要倒着头向后来看，不是很方便。</p><p>到了恒山脚下，我决定还是坐摆渡车上山，爬上去，然后索道下来。中间我对象买了个帽子，然后就又去排上山的队。今天可能景区被骂优化过了，所以我们在排摆渡车之前就检票了，没有等很久。一辆车走了之后，等了一会，然后突然开过来五辆车，都并排停了。我们上了第一辆车的最后一排，我对象不太乐意，因为她有点晕车。</p><p>上了摆渡车，很快就到真武庙了，从这里就往上爬。我带了个 insta360 的相机，可以看到，全程都很简单，我觉得都没有南京紫金山难爬。中间有个庙，爬上去的石阶比较陡，感觉应该是最困难的部分了，但其实也就那样。然后从庙出来，就是冲顶阶段了，过了一个叫氵麦极门的地方之后，就看到小红书上堵人的地方，我们不出意料也开始堵了。感觉就是从这里开始，台阶变得高了点，所以有的人就要歇歇了，加上石阶又变窄了，所以交通就阻塞了，好在这一段不是很长，很快就到了一个亭子那。那是一个三岔路，往左是索道下山方向，往右是登顶方向。我们登顶，好在那里石阶就宽很多了，基本都可以跑起来，所以跑了大概十几分钟，我也登顶了。总共算上等的时间是六十几分钟吧。总的来说，恒山其实没啥意思，主打一个五岳打卡。然后确实很多人都在峰顶的那个地理标识那边排队拍照，说那边一个人只有 20s 的拍照时间。</p><p>下到缆车的地方，看到人也不是很多，就打算坐缆车，结果下来之后发现别有洞天，还是排了不少的。不过其实是可以忍受的，实际上也就等了不到二十分钟。中间前面的京爷因为不知道什么事情吵起来了，然后又打起来了，然后又吵起来了，反正我们就翻栏杆排到了他们前面，感觉也是个乐子。下山就直奔摆渡车站，去古城的在排队，但是去悬空寺的不需要排队，我们就直接上了。</p><p>很快就到了悬空寺，看到很多人在往里面走，好像是自驾过来的，所以我其实有点想看完悬空寺就直接打车回去浑源古城看永安禅寺，省得坐他那个摆渡车兜圈子了。anyway，我们往里面走，是茫茫多的人，然后进去也要走一段路。反正到了悬空寺下面，感觉其实进不进去看也一个样子了，不过来都来了，就进去看一下。里面就是一个小广场，给你拍拍照，然后有一个地方是登临的入口，感觉排了一堆人，我们估算了一下，感觉肯定不止景区宣传的 3260 人每天的量。然后这波人是一波一波往里面放的，所以大家都只能慢慢等，我挺庆幸自己没找黄牛买票，感觉过来排队也还是受罪。过了一个桥，可以更近看悬空寺，不过其实没啥区别，主要这寺确实很小。我对象说梁思成其实也不怎么 care 这个寺，我也不知道为啥。</p><p>出了门，问了保安，说这边社会车辆进不来，他也不知道哪里能打车。我打开滴滴，发现自己站的地方就能打车，所以滴滴肯定是在扯淡。既然打不了车直接去浑源古城，我们只能坐大巴先去游客中心了。快到游客中心我们就远远看到了电瓶车，等下了车，我们就扫了个更近的电瓶车，往浑源古城那边骑。这电瓶车还挺贵的，骑了几公里，扣了我四块钱。</p><p>到了浑源古城，先去永安禅寺逛了下，这个也是辽金时候的建筑，也是出现在浪浪山这个电影里面的。主要看的是它主殿的壁画，正面是画的各个法王，最有名的就是不动明王，他是一个白净的，撕开脸的造型，和其他的法王区别很大，所以他在文创上的露脸也很多。另外一个法王的眼睛很奇特，从左边看是紫色的，从右边看事棕色的，说是因为它眼睛是用贝壳做的，所以有不同的反光。然后左右两边的说是明清的时候画的，其中右边的好像是道教的一些人物，不太看得懂，左边的听了一圈解说，说是佛教里面的六道轮回。我们蹭了好几个解说，所以大概都听了个明白，其中有个解说甚至把谁是东海龙王，谁是地藏王都指出来了。讲解还贴心的照了一下壁画，给我们看这个壁画实际上是有厚度的。</p><p>从永安禅寺出来，就去吃了下小媳妇凉粉。浑源这边遍地都是小媳妇凉粉，但是我们吃的好像是真的小媳妇。点了个凉粉，还有个熏蛋。凉粉啥感觉记不得了，熏蛋还真的挺有意思的。喝了他们的沙棘汁，感觉不如昨天的紫泥的酸。</p><p>骑电瓶车回去，差不多要赶六点的直通车。发现根本找不到直通车的乘车点，百度地图真的是拉胯，但是切换高德地图也找不到。反正问了一圈，终于找到了一个标志，跟着走下去。发现除了 901，还有 25 块钱和 39 块钱不一样的直通车。因为我们已经买了 39 块钱的，所以就过去检票。然后因为我们买的是 7 点的，所以还涉及到改签的问题。第一班车已经只剩下最后两个坐了，所以我们跟检票的小哥一顿交涉，跟着前面几个妹子一起去坐下一班车了。然后小哥上来先让我买一个新的票，然后他再给我把老票直接退了。然后就是等，车很快又要坐满了，中间来了两个女的，发现又只有最后一排的坐了，就想等下一班，但是司机说又已经检过票了。反正折腾了一圈，她们去打车了。然后上来了几个，又有不愿意坐最后一排的，总归折腾了很久还是发车了。</p><p>我们选择在大同南站下车，因为我们路上排了两家凯鸽都要等一段时间，我希望去宾馆洗一下屁股，顺便看看有没有其他能吃的。这个时候琥珀也要来找我，说怎么说再吃个饭按摩一下。因为太饿了，我还请宾馆帮我热了下昨天的肘子垫吧垫吧，不得不说，那肘子还是可以的。然后我就让他来宾馆，自己也顺便洗了个衣服。然后他到了，我们发现凯鸽水泉湾店快排到了，然后就赶快打车过去。到了之后，我对象进去等，我们出去逛了下，发现旁边就是他们的御河，我理解就类似于太原的汾河吧，不过没有自行车道，感觉不如太原做得好。</p><p>凯鸽的菜：</p><ul><li>风沙鸡：感觉很一般，就跟我们这边普通的脆皮鸡差不多</li><li>糖醋里脊：很香，我理解主要还是山西那边醋确实强调香吧，然后就是也没有那么甜</li><li>炸油糕：我朋友说不好吃，不过我们点了个尝一下还不错</li><li>烧麦：皮跟纸一样，但吃起来感觉没啥意思</li><li>羊肉火锅：感觉一般，我对象说味道太重了，我倒是挺喜欢这味道，但是我觉得太肥了，有点我点的锅圈食汇的肥羊的感觉，不是很喜欢</li><li>沙棘汁：还不错，没有紫泥的酸，但是挺普适的</li><li>酸奶：挺好</li><li>烤骨头：有点里脊肉的味道，但是是肘子的感觉，挺有意思的</li></ul><p>一边吃，一遍搜附近的按摩，感觉这边按摩都挺喜欢擦边的。我觉得心思放在擦边上的店基本上手艺挺一般的，所以我直接过滤掉了。反正最后选了一家 150 的，其实做下来感觉也挺一般的。这家店开在小区里面，我们过去的时候，也是穿过小区走过去的。中间我们又看到了山西的省灯，我觉得他们是不是会暗自较劲，看谁家的灯最花里胡哨？反正到了那家店，感觉是个坑姐妹钱的店，全是美容的设备。我们的 80 分钟果不其然是只按 60 分钟，然后做个热敷 20 分钟。然后他们急着下班，又边做边热敷了。我做的是什么泥膜，感觉非常烫。我感觉自己可能都要被烫伤了，就让他给我摘下来，一摸发现全是黏糊糊的汗。因为一直在烫伤的那种疼，所以让她拍照片发现皮肤是白的，看来确实是没有烫伤。不过这个后劲确实大，我大概缓了有一个多小时，这个烫伤的感觉才消失。所以这样看来，感觉这个泥膜还是挺舒服的。</p><h1 id="D5-初五"><a href="#D5-初五" class="headerlink" title="D5 初五"></a>D5 初五</h1><p>今天算是比较奇妙的一天。首先，昨天晚上睡觉前跟我对象讨论了，说今天早上去应县木塔吧。然后晚一点我就想把直通车的票买了，结果一看，9.30 的票只有一张了。因为木塔下午人多，并且，从木塔回古城更顺，所以我们又只能买早上的，就很尴尬。我还不信邪，又刷了几遍，中间还错买了去恒山的，总归坐直通车是不行了。灵机一动，决定去搜下有没有其他的巴士，结果 902 好像要两个多小时，不过中途发现，应县是有高铁站的，并且高铁站也是有巴士去木塔景区的，所以我就决定买火车票了。结果 12306 晚上关门，没法买票，于是我只能定了早上的闹钟。早上起来，发现买票是需要在系统里面排队的，我等了几十秒发现还没刷出来，就又小眯了会。几分钟又醒了，发现刷了两个不挨着的座位，果断付了款，结果再一开，火车票就卖空了。</p><p>结果上了高铁，发现这趟高铁也不算特别挤啊，不知道在那里票都卖光了。不过我们一站就到了应县西站，然后门口就是蓝色巴士，五块钱就到木塔了。然后发现这个巴士似乎也接路上的村民，并且送到木塔之后，也会继续往前开的。</p><p>因为我们是高铁来的，所以应该比大部队要早，到的时候，木塔没啥人，跟之前小红书上看到的完全不一样。我们进去之后，逛了两次一层，分别是从左边和右边走的，所以对里面的雕塑和浮雕看的都比较清楚。印象里面，可以看到木塔是有梯子可以上去的，不过特别陡。然后佛像正面是有两个洞，说是之前被破坏过。</p><p>实际上我们去的时候，木塔二层上是有工作人员在跑动的，只是不知道他们在做什么。站在木塔下面，如果角度不对，其实是不太看的出来木塔已经歪了的。但是确实能看到它的暗层，也确实能看到之前被敲掉的泥墙被换成的窗户，也理解那边的本地人为什么要把泥墙砸掉，因为换成窗户确实好看。</p><p>木塔一个拍照片的角度，就是他的几个底座的角落，我们在那边拍了照片，感觉挺好。不过如果要看木塔，我觉得还是站在下面比较好，我觉得是非常漂亮的，有种雍容华贵的感觉。特别是当你看到木塔周围那些拆迁到一半的破落房子和杂物堆的时候，这个木塔就更有一种清水出芙蓉的感觉了。</p><p>准备离开木塔的时候，风突然大了起来，并且沙子也多了。身边的游客在感叹，这地方还真的是太干旱了，风沙多，结果后来才知道，这是多年没见过的沙尘暴，是从蒙古国吹过来的。总而言之，离开的时候，回望木塔已经是灰黄笼罩的一片了。</p><p>前面那条街还在表演，看了会，就往回走，结果那妖风是越来越大了。走到南门出来的哪个巷子中，推开一个铁门，然后就走到一片很很乡下的地方。前面几个人躲着不肯走，我们过去一看，好家伙，前面黄沙都飞起来了。因为我们赶时间，就硬走过去了，我对象新买的帽子不知道什么时候被刮飞掉了。我们来回找了一下直通车在那里，因为之前在刮风那里确实远远看到“景区”几个字，但是走过去发现不是景区直通车，而是景区官方什么什么的。反正最后问了人，确定了就是在净土寺的广场，和我在微信公众号上看的一样的，所以我就直接导航到净土寺，总算是赶上了。不过上去之后，又是最后一排的位置。不过幸好之后还有一堆人要上车，所以最后我们换了个更大的车，因此又做到前面了。</p><p>上车发现琥珀发的消息，说是已经登机了，结果是什么沙尘暴，说又被赶下飞机了，气的要死。难怪我们这全是沙子，我先前以为他们这每天都这样呢，心想这样也太不好过了吧。</p><p>下午的计划是去古城看华严寺和善觉寺。我们先到古城看看晋喜道的情况，当然是停止放号了，跟我们说晚上的号下午四点开始发，要我们到时候来取。然后就网上搜了下刘姥姥豆面，发现在那个全是牌坊的十字路口，于是就过去。因为中途路过北魏家宴，所以我就说我们也去取个号，我对象说包取不到的，我就不信邪，结果还真只要排一小会，所以我们就先去吃了刘姥姥豆面，顺便等北魏叫号。</p><p>BTW，从下车的那一刻起，我们就感觉到了这个沙尘暴的厉害。进入古城，发现里面人少了很多，估计是风太大都不敢出来了。古城里面的灯会据说也是取消了。走到那个牌坊路口的时候，感觉自己仿佛到了黑沙滩，这风打在脸上是真的疼。琥珀说他的飞机已经延误到三点多了，然后我说你能不能航旅纵横买一个延误险，我看这风，你们三点估计都起飞不了，他说买不了了。实际上后面看小红书，就是我们快到古城，然后下车，也就是 12 点到 1 点那阵子风沙是最大的。</p><p>回到刘姥姥面馆，这面馆也是一个要看本事 DIY 座位的地方。不过好处是它有夹层和二楼，所以我们在二楼找到了个位子。我们点了一些小菜，以及一碗面，里面有它的豆腐干，还有两条青椒。</p><p>吃完刘姥姥，看到北魏的号是刷刷刷地过，突然就只有三个了。我们赶快跑过去，我对象还摔了一下。到了的时候，只有一个号了，所以我们就可以预点菜了。</p><p>吃完北魏，就去华严寺了，这又是蹭解说的一天。一进去，感觉里面鲜花盛开，我以为是冬天快走了，开了一堆梅花，结果走近一看是假的。华严寺一个看点就是大雄宝殿，这个大雄宝殿有一对超级大的鸱吻，另一个特别的是它的入口的门造型比较奇怪，据说是借鉴了伊斯兰教的一些风格。这个大雄宝殿里面到底是啥，因为里面很挤，解说声音又很小，所以我也没啥印象了。然后是普贤阁和文殊阁，好像一个是新的，一个是旧的。我看牌匾全是颜真卿题的，但看这个样子，感觉不是什么老物件。看完大雄宝殿就准备走了，但是发现那边还有个华严塔，然后那个塔排了好长的队。一查，原来是有个纯铜打造的地宫，于是决定还是排吧。当时风还是挺大的，所以我们顶着风排了好久，我中途还要上厕所也是忍下来了。这玩意要排队是因为它要换鞋套，这就慢了。然后首先是下地宫，这个地宫还是不小的，里面有一个台子，供奉了舍利子。相比南京的大报恩寺，这个舍利子还是挺慷慨的，能够够着看到，感觉就是个比较长的米粒一样。逛完了地宫，就往上走，爬塔。据说这个塔是仅次于应县木塔的塔，因为应县木塔不让爬了，所以要爬这个塔。爬的感受就是小号的姬路城，我觉得比较好的是爬的过程中可以看到塔的暗层。暗层实际上有很多像倒金字塔一样的结构，不知道是干嘛的。塔总共有三个明层，上面没啥好看的，风景也一般。下来之后，就准备出去了，半路上看到一个薄伽教藏殿，这个殿是个比较屌的殿。里面全是佛像，佛像上全是灰，解说的意思是这个灰从佛像造完之后，就没有被清理过了。里面有一个佛像是一个露牙齿的女的，说是照着一个小女孩做的，反正我也不是很懂，反正梁思成说很屌，有个什么称号。</p><p>逛完华严寺，刚好四点多了，赶快出去抢号。结果发现晋喜道拿号居然也要排队，我们拿的是 c90，取号的小哥说也不知道要排到啥时候，反正五点钟才开始叫号。所以我们赶快去逛一下善化寺，因为善化寺在南门，所以我们要走好远。基本上就是第一天我们到大同古城走的路线了。反正到了之后，善化寺门口有一个五龙壁，说是之前什么寺拆掉了，然后移动到善化寺门口的。进去之后，当然又是蹭导游了。善化寺的一个重点是它的三圣殿，这个殿比较有名的是那个像菊花一样的斗拱，说这个斗拱即使是辽金的建筑都很少见。然后它的大雄宝殿里面也是一些塑像，有一个塑像比较有意思，是说一个小鬼被点化成为一个善良的送子娘娘，然后就把他们一起塑像了，说是很少见的。然后讲解还介绍了一下工艺，说是塑像是整体镀金的，然后需要显示金线的地方，就把颜料扣掉。另一个塑像栩栩如生，讲解说他腿部的青筋都被雕刻出来了。这个殿里面还有个碑，说是朱熹的什么亲戚的，有一个讲解还指着说第几行有什么字，然后说了什么事情，我是没搞懂。总之觉得这两个殿，旅途随身听的讲解做的比较烂，得一直蹭讲解才行。</p><p>在排队的时候，我要上厕所，结果用百度找了几个厕所，一个都没有用，还是问的别人。后面立即下了高德，发现高德是准的。上完厕所，就直接去晋喜道了，当时已经快排到我们了。我们点了个肉末的面，一个番茄面，几个小菜，鸡爪，串和沙棘汁。小菜方面，我觉得山西的醋确实香，配上大蒜末，所以那个蒜泥肘花就很好吃了。鸡爪感觉就是茶叶蛋的味道。凉拌黄花算是山西特色了，和其他店里没啥区别。肉末面和昨天吃的老柴总店也是比较类似的，不过没有那么咸，更有点汤面的感觉。番茄面比之前在全季早饭吃的稍微好点，主要它不太是那种面是面，浇头是浇头的感觉，相对来说入味点，番茄泥也弄得比较干净。</p><p>因为这两天走的屁股都肿了，所以吃完走到东门打了个车，就直接回去了。中途看到了九龙壁，隔着栅栏看挺漂亮的，结果进去还得买十块钱的票，那谁还进去看啊。等车的时候发现和阳门对面的城楼，也有一种晋祠的感觉。</p><h1 id="D6-初六"><a href="#D6-初六" class="headerlink" title="D6 初六"></a>D6 初六</h1><p>今天在大同逛一下博物馆，就可以回呼和浩特了。早上起来退房，打车去博物馆。我们没有抢到预约，所以只能买特展的票。一开始我以为可以在门口给大爷看完就退了，结果发现这只是一个预检票，后面还有一道需要刷二维码的闸机呢。</p><p>进去之后，逛了一会一楼，上了个厕所，出来然后一个女的就问我们要不要拼团讲解，说是 100 块钱，看我们可能要急着走，就说 80 块钱算了，结果我们就定了。中间想先去看一半穆夏的特展，结果人家说只能进去一次，所以就放弃了，又下来。不过好在那讲解员拉客能力比较强，很快就齐活了，她先照着大厅里面的那个壁画讲了一遍，后面我们才知道，这个壁画并不被公开展示。然后我们就又从恐龙那边开始逛了。不过不同的讲解员的路线略有区别，所以我们这次就没有讲那个编织壶。我问了下，那个恐龙为什么那么完整，讲解员说这个叫什么天镇恐龙，当时挖出来也不是完整的，说是考古学家拼的。反正没懂我意思，因为有些恐龙是会缺几个骨头的，但是这几个恐龙是完整的。</p><p>二楼是比较精华的部分，即北魏展厅，因为大同直接是北魏的都城。其实它有两个展厅，讲解员只带我们逛了第一个。第一个中又分为两个主题，第一个主题是一个墓葬里面的发掘物，包含了漆画屏风以及它的附属，包括挂它的架子、柱子、石墩子都展示出来了。然后还有对应的墓志铭，以及一些陪葬的陶俑。第二个主题是丝绸之路，包含一些陶俑、壁画以及玻璃制品。这里的玻璃制品还是很漂亮的，是非常剔透的蓝色。</p><p>三楼是辽金和明清展厅，大同是北魏的陪都。然后，看到了一个非常大的鸱吻，说是从某个大殿上拿下来的。说鸱吻是龙和鲸鱼的后代，它长得就很像鲸鱼的尾巴。</p><p>讲解团解散之后，就去逛了下穆夏的特展。这个人是画板画的，不过眼睛画的很传神。另外，他也会画油画。看完特展，我发现二楼其实还有个展厅没看，所以就又下去看那个展厅。</p><h1 id="D7-初七"><a href="#D7-初七" class="headerlink" title="D7 初七"></a>D7 初七</h1><p>今天早上打车去了大召寺。这个寺是藏传佛教的，我不太懂，感觉没啥意思。有一个乃琼庙，里面都是骷髅头，很吓人。</p><p>从大召寺出来，就是塞上老街，我们又去吃了泽成冰煮羊，吃完，就打车去内蒙古博物馆。这个车是真离谱，调个头就花了十几分钟，堵得要死，结果我们等了有 20min 才上车。</p><p>内蒙古博物馆是真的大，感觉建得跟人民大会堂一样，里面也很大。我们预约的早上的，结果下午去就刷不进去了，被门口的说了下，就放进去了。一楼的展厅没有时间看，就奔着二楼去了。二楼是一堆乱七八糟的展厅，影响深刻的有一个马年的特展，还有一个神舟飞船的展厅。另外，他有一个特别大的古生物的展厅，里面放了从寒武纪奥陶纪，到恐龙时代的各种化石。我怀疑这个博物馆跟云南哪里有什么合作，因为它展出了很多云南出土的文物。</p>]]></content>
    
    
    <summary type="html">&lt;p&gt;过年期间去了呼和浩特和大同。这是首个依照 codex 做的旅游规划玩的活动。&lt;/p&gt;</summary>
    
    
    
    
    <category term="游记" scheme="http://www.calvinneo.com/tags/游记/"/>
    
  </entry>
  
  <entry>
    <title>Vibe 一个桌游模拟器</title>
    <link href="http://www.calvinneo.com/2026/01/30/vibe-open-board-game/"/>
    <id>http://www.calvinneo.com/2026/01/30/vibe-open-board-game/</id>
    <published>2026-01-30T15:09:06.000Z</published>
    <updated>2026-10-20T00:59:39.956Z</updated>
    
    <content type="html"><![CDATA[<p>作为一个桌游爱好者，我打算用 Codex 去 Vibe 一个桌游模拟器，这样我可以尝试自定义规则和 Bot 强度。这篇文章我会介绍我 Vibe 的经验。</p><p>我的项目是 <a href="https://github.com/CalvinNeo/OpenBoardGame%E3%80%82" target="_blank" rel="noopener">https://github.com/CalvinNeo/OpenBoardGame。</a></p><a id="more"></a><h1 id="D0"><a href="#D0" class="headerlink" title="D0"></a>D0</h1><p>作为 Demo 实现了一个掼蛋游戏。 </p><p>发现问题：</p><ul><li>AI 对规则理解非常不正确，例如缺少对三带二、同花顺炸弹的支持，并且也不能顺子的长度和一手牌数量的上限。</li><li>AI 对空间感不熟悉，一些提示文字和牌重合。</li></ul><h1 id="Jan28-Jan29"><a href="#Jan28-Jan29" class="headerlink" title="# Jan28 - Jan29"></a># Jan28 - Jan29</h1><p>在这 2 天中，我大概用了 45 刀左右的额度。完成了 Cabo、骷髅牌、你画我猜、璀璨宝石四个游戏逻辑和 Bot 的开发。并且，我还支持了断开重连、房间管理等机制。我还优化了 UI 的美观度和便捷度。</p><p>AI 会理解错一些点。例如 <a href="https://github.com/CalvinNeo/OpenBoardGame/commit/ab26a9c00cd5d9720b39bf3e248b672881cb52ed" target="_blank" rel="noopener">https://github.com/CalvinNeo/OpenBoardGame/commit/ab26a9c00cd5d9720b39bf3e248b672881cb52ed</a> 这个修复 commit 就展示了 AI 对璀璨宝石最大数量的多次理解问题：</p><ol><li>一开始，它根本没有实现这个限制。</li><li>后面，它实现为只有超过 10 才不能拿，但是从 9 到 12 这个行为是被它允许的。</li><li>最后，才修改对了。</li></ol><p>AI 会漏掉一些情况。例如 <a href="https://github.com/CalvinNeo/OpenBoardGame/commit/c8e82736975325f0b9300b471524ec86b005129e#diff-794e220aafafcfac193a89abd6fb142d92255d544728f217d64e7a1162c79e28" target="_blank" rel="noopener">https://github.com/CalvinNeo/OpenBoardGame/commit/c8e82736975325f0b9300b471524ec86b005129e#diff-794e220aafafcfac193a89abd6fb142d92255d544728f217d64e7a1162c79e28</a> 这个修复 commit 展示了 AI 对用户离开规则的遗漏：</p><ol><li>先前，AI 处理了 in game 的情况。此时如果最后一个活人玩家离开游戏，那么这个房间可以被手动清理掉。</li><li>但是，它漏掉了 in lobby 的情况。此时房间并没有开始游戏，那么玩家离开房间（比如创建一个新的房间）不会导致该房间出于可以被清理的状态。</li></ol><p>经验：</p><ul><li>让 agent 缩小阅读的范围。例如可以告诉它“这是完全的前端修改，你不需要看后端代码或者其他游戏的代码”，这样它就可以更快解决问题，并且能节省不少额度。这随着项目增大是尤为有效的，因为看 thinking 是可以发现它有倾向去学习其他代码是怎么做的。</li><li>让 AI 先整理信息，然后再写一个 design 征求意见非常重要。因为 AI 在实现的时候还是偏向于漏点东西的，这也可能是出于对问题的不正确理解。</li><li>逻辑比较独立的部分，可以让 AI 整理出测试。虽然目前也没看到 AI 会主动修改代码从而 break 掉测试，但这样会更有自信。</li></ul><h1 id="Jan-30-Jan-31"><a href="#Jan-30-Jan-31" class="headerlink" title="Jan 30 - Jan 31"></a>Jan 30 - Jan 31</h1><p>这几天主要实现了出包魔法师、猜狐狸、截码战三个游戏。</p><h1 id="Feb-1-Feb-3"><a href="#Feb-1-Feb-3" class="headerlink" title="Feb 1 - Feb 3"></a>Feb 1 - Feb 3</h1><p>这几天主要实现了角斗士棋、Store&amp;Load、印象花语、AI 画物语四个游戏。主要是由 Gemini 生成游戏说明书，再由 Codex 生成 design。等我 Review 了之后，再实现代码。</p><p>角斗士棋和印象花语中都涉及到了拖拽旋转对象的设计。我发现 AI 在适配手机端上的拖拽是相对比较蠢的，需要手动告诉怎么搞。</p><p>角斗士棋实现起来很简单，但是其实要打磨的很多：</p><ul><li>手机版如何精准地把方块放到格子里面就很难困难。因为每个方块的焦点并不是方块的重心。后来加了上下左右移动的键，但是感觉还是很蠢。</li><li>还有一些奇怪的 bug。</li></ul><p>印象花语这个游戏，我对实体版的一些物理效果进行了模拟：</p><ul><li>因为印章可以印得深浅不一，所以我增加了点按时长来决定透明度的机制。并且我也增加了根据色彩学原理来模拟印章叠加的效果。</li><li>因为可以倾斜印章，使得只盖一半。所以我增加了一个 Mask 机制，可以去 Clip 印章。这个就好像我在按之前垫了一张废纸，这样章可以只盖一半在画布上。</li></ul><p>我觉得这一部分涉及到物理世界的原理的，应该只有人类能意识到并且提出来。</p><p>Store&amp;Load 是非常有意思的点，AI 当时给我提供了一个完全不一样的解决方案。例如它执着于解决 Session 的问题，如何处理同名玩家和同名 Room。但是我提出了一个非常简单的做法，就是完全新建一个 Room，然后新玩家可以进去 Claim 老玩家的 Seat。这样做能够减少很多的复杂度。另外，我还发现新创建的房间并不支持 Auto Save 选择了，这个我觉得也是 AI 本身缺乏引申的能力。</p><p>AI 画物语的实现是跟其他桌游完全不一样的，因为要涉及生成图。所以我开了 <a href="https://github.com/CalvinNeo/aidixitgen" target="_blank" rel="noopener">https://github.com/CalvinNeo/aidixitgen</a> 这个 repo。</p><p>一开始它是用的 pollinations 做的。然后我发现这个工具经常生成水母，然后问了他，他说是提示词的问题：</p><blockquote><p>为什么这个代码里面的 prompt 这么喜欢生成 jellyfish？<br>这是一个非常经典且有趣的 AI 生成现象，通常被称为 “模式坍塌” (Mode Collapse) 或 “安全区偏差”。出现大量水母（Jellyfish）、热气球、云朵、漂浮的岛屿，原因主要有三点：<br>关键词的“刻板印象”： 你的代码里用了 surreal（超现实）、dreamlike（梦幻）、whimsical（异想天开）这些词。 在 AI 的训练数据（Latent Space）里，水母是“梦幻”和“超现实”的超级代表物。它们透明、发光、漂浮，长得就像外星生物，完美符合 AI 对“梦境”的理解。只要你还要“唯美”和“超现实”，AI 就会懒惰地选择水母。<br>Prompt 缺乏约束： 我们在请求 AI 写创意时，给的指令太宽泛了（”Generate ONE single short… description”）。当指令太宽泛时，AI 会倾向于输出它认为“最稳妥、最符合题意”的高概率词汇。对于 Dixit 风格，水母就是那个“最稳妥”的答案。<br>风格修饰词的引导： 我们在画图时强制加了 soft colors（柔和色彩）和 floating（虽然没写但 dreamlike 隐含了漂浮感）。这也极大地增加了生成海洋生物或云端生物的概率。</p></blockquote><p>然后，我又发现它生成的东西太容易重复了，例如几乎生成了两个只是风格不同的钟。所以我后面又设计了双主体的方案，结果最后生成的结果是比较理想的了。</p><p>后来发现 pollinations 一直 502 了，所以就换 hugglingface 了。</p><h1 id="Feb-4-Feb-6"><a href="#Feb-4-Feb-6" class="headerlink" title="Feb 4 - Feb 6"></a>Feb 4 - Feb 6</h1><p>这几天主要实现了前端美化、Flip 7、德国心脏病、绝妙误解。</p><p>主要是由 Gemini 生成游戏说明书以及设计。然后由 Codex 去实现。但是我要求 Codex 在实现前先问我不清楚的项目，而不是自己随便实现一版。事实发现，让 Codex 去问一下自己不知道的，而不代替我做决定，是很重要的。</p><p>AI 前端的主要问题：</p><ul><li>UI 直白<br>  例如用一个列表表示玩家信息。用一个表格表示当前状态。这对玩家而言体感不好，感觉是在上班。</li><li>没有交互设计<br>  特别是手机端玩家，操作的时候需要翻来翻去。</li><li>UI 可能存在 Bug<br>  例如在手机端会发现 Flip 7 的 Game 面板会非常少。</li></ul><p>德国心脏病的开发是非常典型的。主要包含几点：</p><ul><li>得到的开发计划是经典版的 Halli Galli，也就是牌上的水果一定是相同的。这个跟我们玩的不一样，所以后面让它开发了一个 DLC 一样的东西。</li><li>电脑根本没有给翻拍和按铃的等待时间，所以加上 bot 之后，基本 bot 都是秒按铃，秒翻牌，根本没法玩。即使没有 bot，我们也需要考虑人类的反应时间，以及各个网络的延迟。所以我这里要求加了等待 3s 的按铃时间，以及在点击翻拍后，有一个 1s 的倒计时，方便大家准备看新水果。</li><li>AI 生成的界面依然是列表，这个我让 AI 改成了围成一个圆。</li></ul><h1 id="Feb-7-Feb-10"><a href="#Feb-7-Feb-10" class="headerlink" title="Feb 7 - Feb 10"></a>Feb 7 - Feb 10</h1><p>主要工作是修复之前各个游戏的问题。例如：</p><ul><li>cabo 的规则实现错误</li><li>flip7 的相关问题</li><li>继续修理绝妙误解中糟糕的前端问题</li><li>印章话语支持投票</li><li>支持日志复制</li><li>发现之前代码中有 valid 检查，一直是死代码，启用</li></ul><p>实现了新游戏，包括：Gold Rush、Hanabi、Cyber Pictures、The Gang、逻辑猫。</p><p>对 FRONTEND.md 进行了修订，后续的移动端 UI 开始要好一些了。</p><p>此外，还支持了新的功能：</p><ul><li>Download Memories，用来下载整个游戏的回放<br>  实现的过程中，发现设计非常死板。例如花了大篇幅去展示什么 user id，但是游戏内容就缩在一小列里面。而且他非常喜欢表格。</li><li>在游戏过程中开启 Auto Save</li></ul><h1 id="Feb-11-Feb-12-Feb-26-27"><a href="#Feb-11-Feb-12-Feb-26-27" class="headerlink" title="Feb 11 - Feb 12, Feb 26-27"></a>Feb 11 - Feb 12, Feb 26-27</h1><p>主要支持了我画我猜、方鸟、小早川、牛头王。快艇骰子。</p><p>方鸟这个游戏非常有趣，是 Gemini 生成了一段很有歧义的规则说明，然后 Codex 直接按照错误的方式理解了。</p><h1 id="Feb-28-Mar-12"><a href="#Feb-28-Mar-12" class="headerlink" title="Feb 28 - Mar 12"></a>Feb 28 - Mar 12</h1><p>这段时间开始尝试探索 AI 多模态能力的边界。主要开发的游戏有历史奇旅、卡卡颂、德州扑克、project L、璀璨宝石宝可梦。此外，还尝试了诸如 Claude code 等其他模型的能力。</p><p>其中：</p><ul><li>历史奇旅主要是识别质量较高的游戏卡牌</li><li>卡卡颂是识别卡牌，并能拓扑地利用它们<br>  实际上，识别是最难的。我大部分时间用来调试 Codex 生成 72 个基础地图。Codex 经常是分不清城堡是否占边，是否占角。还分不清城堡和道路的重合关系。在生成 svg 的时候，非常喜欢用圆而不是二次曲线去拟合，导致生成的图片很僵硬。<br>  但是，一旦生成成功，后面包括地图连通性判断就非常简单，直接一遍过。</li><li>project L 是阅读游戏说明书，然后生成<br>  这里面主要是前端显示问题。就是一个 svg 生成好好的，让它转成前端，就变成了长方形的长条而不是正方形的格子了。</li><li>宝可梦是识别质量较低的游戏卡牌<br>  可以说非常痛苦，目前来看人工校对是必要的。强烈建议对于这种任务，让 ai 首先生成一个校对工具，这样每次的错误至少是能收敛的。另外，确实是有 corner case AI 无法识别，这样就只能人工标注。<br>  另外，这种 case，AI 喜欢写一段识别代码，我建议提示 AI 不要用 tesserocr。另外，这种类似于“蒸馏”的方式其实挺好。</li></ul><p>此外，还进行了一些优化：</p><ul><li>将 app.js 拆分以减少 tokens 开销</li><li>引入 vendor 减少 cdn 故障导致的无法游戏</li><li>增强游戏选择界面</li><li>引入帮助功能</li></ul>]]></content>
    
    
    <summary type="html">&lt;p&gt;作为一个桌游爱好者，我打算用 Codex 去 Vibe 一个桌游模拟器，这样我可以尝试自定义规则和 Bot 强度。这篇文章我会介绍我 Vibe 的经验。&lt;/p&gt;
&lt;p&gt;我的项目是 &lt;a href=&quot;https://github.com/CalvinNeo/OpenBoardGame%E3%80%82&quot; target=&quot;_blank&quot; rel=&quot;noopener&quot;&gt;https://github.com/CalvinNeo/OpenBoardGame。&lt;/a&gt;&lt;/p&gt;</summary>
    
    
    
    
    <category term="游戏" scheme="http://www.calvinneo.com/tags/游戏/"/>
    
    <category term="agent" scheme="http://www.calvinneo.com/tags/agent/"/>
    
  </entry>
  
  <entry>
    <title>3FS 学习</title>
    <link href="http://www.calvinneo.com/2026/01/15/study-3fs/"/>
    <id>http://www.calvinneo.com/2026/01/15/study-3fs/</id>
    <published>2026-01-15T15:09:06.000Z</published>
    <updated>2026-05-27T13:26:57.728Z</updated>
    
    <content type="html"><![CDATA[<p>学习 3FS。</p><a id="more"></a><h1 id="原理"><a href="#原理" class="headerlink" title="原理"></a>原理</h1><h2 id="解决什么问题"><a href="#解决什么问题" class="headerlink" title="解决什么问题"></a>解决什么问题</h2><p>3FS 作为一个训推一体框架，解决的几个痛点是：</p><ul><li>痛点一：AI 训练中海量数据的“随机读取”瓶颈 在模型训练时，数据加载器（Dataloader）需要不断对海量的训练样本进行全局 Shuffle（打乱重排）以防止模型过拟合。这会产生极其庞大的纯随机读取操作。在传统架构下，为了不让 GPU 等待数据，往往需要预先将数据搬运到计算节点的本地硬盘上。3FS 聚合了全局极高的并发随机读取能力，让计算节点可以直接像访问本地文件一样，在全局数据集上进行无感知的随机采样，省去了繁琐的数据预取和搬运。</li><li>痛点二：传统文件系统“读缓存失效”造成的内存浪费 主流的操作系统高度依赖 Page Cache（页缓存）和预读机制来加速文件读取。但在 AI 训练的随机洗牌场景下，读过的数据短时间内几乎不会再被重复读取。这意味着传统的“缓存”不仅完全无效，还会大量无谓地侵占计算节点的系统内存，甚至干扰训练任务的稳定性。3FS 针对这一点进行了彻底剥离，它主要依赖 Linux AIO 和 io_uring 直接处理 I/O 操作（Direct I/O），完全抛弃了对本地文件缓存的依赖，把宝贵的内存还给了计算任务。<br>  关于这一点，可以参考 Are You Sure You Want to Use MMAP in Your Database Management System？ 这个文章。我们在使用 tantivy 的时候，也发现 tantivy 的 mmap 会逃逸 tiflash 读节点的内存管理，导致频繁出现 memory over limit 的软限制，导致查询报错。<br>  我们开发的 tici 使用的 tantivy 会使用 mmap，并且会对每个 fragment 做 cache。mmap 无法直接控制，frag cache 目前也是必须的，所以这一块的内存管理很被动。</li><li>痛点三：超大规模集群的“并行 Checkpoint”风暴 万卡集群在训练千亿/万亿参数大模型时，需要高频保存模型权重状态（Checkpoint）以防硬件故障导致训练白费。这就要求系统必须在极短的时间内，将几十 TB 甚至上百 TB 的数据同时且高并发地砸进磁盘。3FS 极高的吞吐上限（官方测试可达极高的 TiB/s 级别），将写入 Checkpoint 导致的集群全量停机等待时间压缩到了极致。<br>  这里面的 Checkpoint 不仅是模型参数 Weights（每一层的权重），还包括优化器的状态，如 Adam 优化器的一阶矩和二阶矩，梯度和一些元数据等。主要的内容是 Adam 部分。<br>  假设你在训练一个 1,750 亿参数（175B）的模型，以半精度（16-bit）保存，权重约 350GB。但加上优化器状态后，一个完整的 Checkpoint 可能高达 2TB 左右。如果是一个万亿参数（MoE 架构）的模型，单个 Checkpoint 达到 10TB-20TB 并不罕见。为了容灾和实验回溯，集群通常会保留多个步数的副本，因此总占用达到百 TB 级别是非常正常的。</li><li>痛点四：推理阶段 KV Cache 的容量与成本限制 在处理超长上下文（Context）的 LLM 推理时，保存在昂贵 GPU 显存或系统内存（DRAM）中的 KV Cache 会迅速触及容量天花板。3FS 极低的读写延迟和超高并发，让 DeepSeek 能够实现“将 KV Cache 卸载到廉价高速磁盘（SSD）上”的技术方案。这为超长文本的推理提供了一种极具性价比的替代路径。</li></ul><h2 id="3FS-的方案"><a href="#3FS-的方案" class="headerlink" title="3FS 的方案"></a>3FS 的方案</h2><p>对此，3FS 的方案是：</p><ol><li>把显存 offload 到 SSD 上。主要还是借助 NVMe 和 RDMA 技术。</li><li>Global Prefix Caching：我理解这一部分主要的优化点是超级冗长的系统提示词 (System Prompt) 以及各种套娃。</li></ol><p>另外，是 KVCache 的内存开销，其实是和上下文线性相关的<br><img src="/img/3fs/kvcache-complexity.png"></p><h1 id="设计-–-design-notes"><a href="#设计-–-design-notes" class="headerlink" title="设计 – design notes"></a>设计 – design notes</h1><p>3FS 中有个 design notes，这里主要是概括了 design notes。</p><h2 id="需要解决的问题"><a href="#需要解决的问题" class="headerlink" title="需要解决的问题"></a>需要解决的问题</h2><p>OSS 方面：</p><ul><li>现在的 OSS 并不支持原子地移动一系列文件或者一整个目录，或者递归地删除整个目录。而 3FS 的场景（实际上数据库的场景也是这样）涉及要创建一个临时目录，然后对这个目录写入数据，最后将这个目录 move 到最终的位置。</li><li>3FS 需要广泛使用 symbolic 或者 hard 链接</li><li>提供一个熟悉的文件接口，我理解这也是 3FS 选择 FUSE 的原因</li></ul><p>FUSE 方面：</p><ul><li>在 <a href="/2025/03/09/learn-fuse/">Fuse 学习</a>一文中介绍了为什么 FUSE 不支持 Zero Copy。但这也是 FUSE 的缺点之一。</li><li>FUSE 使用一个由 spin lock 保护的多线程共享的队列。3FS 团队的测试显示，400K 4KiB reads per second 的写入负载之后，因为 lock contention 的方法。</li><li>Linux 5.x 上的 fuse 不支持对一个文件的并发写。所以很多需要更大带宽的程序会并发写多个文件。</li><li>对小的随机非对齐读性能不好，SSD 和 RDMA 网络的带宽没有被利用充分。</li></ul><p>但是将 client 实现为一个 VFS 内核模块则能解决上面说的问题，但也更有挑战性。内核的 bug 更难定位和修复。此外，升级的时候需要停掉所有访问这个 fs 的进程，或者重启。</p><p>因此，3FS 选择在 FUSE daemon 里面设计一套原生的 client，由它来支持异步的 Zero copy IO。其中，File meta operation 例如 open、close 等还是被 FUSE daemon 处理。但是在 open 的时候会把拿到的 fd 通过 native API 注册。然后就可以通过 native client 去读取数据了。</p><p>这个 API 类似于 io_uring，其中关键结构如下：</p><ul><li>Iov<br>  user process 和 native client 共享的内存</li><li>Ior<br>  user process 和 native client 通过这个 ring buffer 进行交互。具体方式类似于 io_uring。<br>  请求会被按照 io_depth 攒批执行，不同的 batch 的执行是并行的。</li></ul><h2 id="Metadata-存储"><a href="#Metadata-存储" class="headerlink" title="Metadata 存储"></a>Metadata 存储</h2><h3 id="chunk-的分布"><a href="#chunk-的分布" class="headerlink" title="chunk 的分布"></a>chunk 的分布</h3><p>文件按 chunk 为粒度，被条带化到多个 replication chain 中。<br>创建新文件的时候，会根据 stripe size，使用 round robin 的方式，选择一系列的 chain。选出来的这些 chain，会随机分给不同的 chunk 写入。</p><h3 id="存储-file-attributes"><a href="#存储-file-attributes" class="headerlink" title="存储 file attributes"></a>存储 file attributes</h3><p>为什么 3FS 的 inode 里的 length 会不准确？因为写路径走的是 CRAQ，而 inode 是在 metadata service 里面的。如果每次写操作完都更新一下 metadata，那么会多一次 metadata RTT，写放大严重，吞吐和延迟都会变差。<br>但是如果 metadata 迟迟不更新，例如是 100mb，而客户端写到 120mb 就挂了，此时，虽然数据已经通过 CRAQ 持久化到 chunk 存储了，但因为读的时候从 metadata 获得的长度偏小，所以还是在效果上丢失数据。<br>一种方式是按照 interval 上报更新 metadata，但这就存在不一致窗口。不过先考虑容灾问题，大概有两个方案：</p><ol><li>重启之后，从 chunk 存储中恢复数据，并由此更新 metadata。但是从 chunk 扫描数据恢复的代价很大</li><li>3FS 的设计是由 client 按照 interval 上报 max writer position，因为 client 上报的 position 一定是已经被 tail 提交了的，所以是安全的。但是如果 client 长期丢失，那么 gap 就得通过第一种方式补齐了。</li></ol><h2 id="Chunk-存储"><a href="#Chunk-存储" class="headerlink" title="Chunk 存储"></a>Chunk 存储</h2><p>Suppose there are 6 nodes: A, B, C, D, E, F. Each node has 1 SSD. Create 5 storage targets on each SSD: 1, 2, … 5. Then there are 30 targets in total: A1, A2, A3, …, F5. If each chunk has 3 replicas, a chain table is constructed as follows.</p><table><thead><tr><th align="center">Chain</th><th align="center">Version</th><th align="center">Target 1 (head)</th><th align="center">Target 2</th><th align="center">Target 3 (tail)</th></tr></thead><tbody><tr><td align="center">1</td><td align="center">1</td><td align="center"><code>A1</code></td><td align="center"><code>B1</code></td><td align="center"><code>C1</code></td></tr><tr><td align="center">2</td><td align="center">1</td><td align="center"><code>D1</code></td><td align="center"><code>E1</code></td><td align="center"><code>F1</code></td></tr><tr><td align="center">3</td><td align="center">1</td><td align="center"><code>A2</code></td><td align="center"><code>B2</code></td><td align="center"><code>C2</code></td></tr><tr><td align="center">4</td><td align="center">1</td><td align="center"><code>D2</code></td><td align="center"><code>E2</code></td><td align="center"><code>F2</code></td></tr><tr><td align="center">5</td><td align="center">1</td><td align="center"><code>A3</code></td><td align="center"><code>B3</code></td><td align="center"><code>C3</code></td></tr><tr><td align="center">6</td><td align="center">1</td><td align="center"><code>D3</code></td><td align="center"><code>E3</code></td><td align="center"><code>F3</code></td></tr><tr><td align="center">7</td><td align="center">1</td><td align="center"><code>A4</code></td><td align="center"><code>B4</code></td><td align="center"><code>C4</code></td></tr><tr><td align="center">8</td><td align="center">1</td><td align="center"><code>D4</code></td><td align="center"><code>E4</code></td><td align="center"><code>F4</code></td></tr><tr><td align="center">9</td><td align="center">1</td><td align="center"><code>A5</code></td><td align="center"><code>B5</code></td><td align="center"><code>C5</code></td></tr><tr><td align="center">10</td><td align="center">1</td><td align="center"><code>D5</code></td><td align="center"><code>E5</code></td><td align="center"><code>F5</code></td></tr></tbody></table><p>这里的 Version 是配置的 Version，节点下线会导致这个增大。</p><p>这里的一个 Chain 类似于一个 Raft Group 的概念。但是它也不是像 TiKV 一样跟某一段数据绑定的。一个 Chain 可以被多个 chain table 包含。引入 chain table 的概念，这样对于每一个 file，metadata service 就可以为它选一个 chain table，并根据这个 table 中的 Chain 去 strip 这个 file 的所有 chunk。</p><h3 id="Balanced-traffic-during-recovery"><a href="#Balanced-traffic-during-recovery" class="headerlink" title="Balanced traffic during recovery"></a>Balanced traffic during recovery</h3><p>如果一个节点 A 故障了，就需要由 Chain 中的其他节点来承担原来 A 的流量。而之前的 Chain table 中，A 节点基本上只和 B、C 玩。</p><p>在新的架构中，A 在 Chain 2 里和 B/D 在一起，在 Chain 5 里和 C/F 在一起。</p><h3 id="Data-replication"><a href="#Data-replication" class="headerlink" title="Data replication"></a>Data replication</h3><p>一个 Write request 可能是从 client 或者 Chain 的前驱发送出来的。一个节点收到 Write request 后的处理：</p><ul><li>校验 write request 中的 chain version。</li><li>通过 RDMA Read 去 pull 写入的数据。如果 client 或者前驱挂掉了，导致拿不到数据。写入就 abort。</li><li>Once the write data is fetched into local memory buffer, a lock for the chunk to be updated is acquired from a lock manager. Concurrent writes to the same chunk are blocked. All writes are serialized at the head target.</li><li>读取这个 Chunk 的 committed version，对它 apply change，然后将更新后的版本存储为 pending version。版本号是单调连续递增的。</li><li>If the service is the tail, the committed version is atomically replaced by the pending version and an acknowledgment message is sent to the predecessor. Otherwise, the write request is forwarded to the successor. When the committed version is updated, the current chain version is stored as a field in the chunk metadata.</li><li>When an acknowledgment message arrives at a storage service, the service replaces the committed version with the pending version and continues to propagate the message to its predecessor. The local chunk lock is then released.</li></ul><h1 id="实现"><a href="#实现" class="headerlink" title="实现"></a>实现</h1><h2 id="Chain-replication"><a href="#Chain-replication" class="headerlink" title="Chain replication"></a>Chain replication</h2><p>CRAQ 的最大的特点是：复制链路是固定的，而 Raft 的复制链路因为存在 Quorum 是随机的。因此，对于单个 entry 的复制，Raft 的延迟可能会比 CRAQ好，但是 CRAQ 的延迟和吞吐更稳定，可以被预测。</p><p>延迟维度的对比：</p><ol><li>Raft 最优<br> a. 条件：follower 延迟几乎一致、没有网络问题<br> b. commit latency 约等于 RTT</li><li>Raft 最劣<br> a. 条件：quorum 中某个 follower 抖动，例如出现了 Write Stall<br> b. Throughput 约等于 1 / avg([max(follower latency)]，这里的 avg 因为抖动是不均匀的，因为多数派每次都不一定一样。</li><li>CRAQ 最优<br> a. 条件：链上每个 node 的 hop_latency 相同，管道用满<br> b. Throughput ≈ min(hop throughput)，这个很简单，木桶效应嘛。</li><li>CRAQ 最劣<br> a. 条件：链上每个 node 变慢<br> b. 存在木桶效应，每个 entry 的提交都被固定变慢。</li></ol><p>吞吐维度的对比：</p><ol><li>Raft 最优<br> a. 条件：同延迟。<br> b. Throughput ≈ follower replication rate</li><li>Raft 最劣<br> a. 条件：同延迟。<br> b. commit latency 等于 max(quorum follower latency)，出现了木桶效应</li><li>CRAQ 最优<br> a. 条件：链上每个 node 的 hop_latency 相同<br> b. commit latency 约等于 chain_length * hop_latency。因为 CRAQ 在 Tail 返回确认，所以 3 副本也是两次数据传输，和 Raft 的 1 个 RTT 是接近的。但是链长了，CRAQ 就会变慢。</li><li>CRAQ 最劣<br> a. 条件：存在一个很慢的 node<br> b. 同上，但是木桶效应被放大很明显。</li></ol><p>CRAQ 的其他特点：</p><ol><li>没有 quorum 容错</li><li>failover 不需要重新选主，但需要重构链。需要根据挂的是哪一个来讨论。</li></ol><h1 id="Reference"><a href="#Reference" class="headerlink" title="Reference"></a>Reference</h1><ul><li><a href="https://github.com/deepseek-ai/3FS/blob/main/docs/design_notes.md" target="_blank" rel="noopener">https://github.com/deepseek-ai/3FS/blob/main/docs/design_notes.md</a></li></ul>]]></content>
    
    
    <summary type="html">&lt;p&gt;学习 3FS。&lt;/p&gt;</summary>
    
    
    
    
    <category term="aiinfra" scheme="http://www.calvinneo.com/tags/aiinfra/"/>
    
    <category term="数据库" scheme="http://www.calvinneo.com/tags/数据库/"/>
    
  </entry>
  
</feed>
