<?xml version="1.0" encoding="utf-8"?><feed xmlns="http://www.w3.org/2005/Atom" ><generator uri="https://jekyllrb.com/" version="3.10.0">Jekyll</generator><link href="http://baotiao.github.io/feed.xml" rel="self" type="application/atom+xml" /><link href="http://baotiao.github.io/" rel="alternate" type="text/html" /><updated>2026-11-13T20:44:51+00:00</updated><id>http://baotiao.github.io/feed.xml</id><title type="html">做有积累的事情</title><subtitle>MySQL数据库内核研发相关</subtitle><author><name>baotiao</name></author><entry><title type="html">MySQL, PostgreSQL 和 DuckDB 的行定位</title><link href="http://baotiao.github.io/2026/11/13/innodb-postgresql-duckdb-rowid.html" rel="alternate" type="text/html" title="MySQL, PostgreSQL 和 DuckDB 的行定位" /><published>2026-11-13T00:00:00+00:00</published><updated>2026-11-13T00:00:00+00:00</updated><id>http://baotiao.github.io/2026/11/13/innodb-postgresql-duckdb-rowid</id><content type="html" xml:base="http://baotiao.github.io/2026/11/13/innodb-postgresql-duckdb-rowid.html"><![CDATA[<p>InnoDB 的二级索引通过主键回表. PostgreSQL 的 heap 索引引用 tid 包含 block number和line pointer, DuckDB 的 ART 引用表内row. 三种引擎在 page 整理时, 要维护各自的行引用和实际记录之间的对应关系.</p>

<h4 id="innodb-的主键">InnoDB 的主键</h4>

<p>以有显式主键的表为例, 主键 B-tree 的叶子页存的就是主键记录. 内部节点用子页号向下路由. 到了叶子页, page_cur_search_with_match 先在 page directory 上二分, 再沿候选记录链比较主键.</p>

<pre><code class="language-text">主键查询     主键 → primary key B-tree → 叶子页内按主键查找 → record
二级索引查询 二级键 → 二级索引记录里的主键 → primary key B-tree → record
</code></pre>

<p>页内整理维护页目录, 记录链和相关的记录锁. 页分裂时, 记录可以搬到另一个页, B-tree 会更新路由. 主键保持原值时, 二级索引可以用同一个键找到搬过的记录.</p>

<p>InnoDB 可以用主键或合适的唯一非空键组织btree. 表里没有合适的键时, InnoDB 生成一个 6 字节的隐藏 DB_ROW_ID 作为主键. <a href="https://dev.mysql.com/doc/refman/8.4/en/innodb-index-types.html">InnoDB 的主键索引与二级索引</a></p>

<h4 id="postgresql-的-heap-tid">PostgreSQL 的 heap TID</h4>

<p>从索引和数据分开存放这一点看, PostgreSQL 普通 heap 表的索引都类似二级索引, 主键索引也是一样. Heap 页里的记录独立于各个索引的键顺序. 如果索引只存 heap 页号, 回表还得遍历页里的 record 找匹配. InnoDB 的记录按主键组织在聚簇树里, 二级索引拿到主键后可以继续查主键树, 到叶子页按主键顺序找记录.</p>

<p>PostgreSQL 的 B-tree 叶子项保存 heap TID. 6 字节的 TID 由 block number 和 line pointer 槽号组成, 取到 heap 页后可以直接访问这个槽.</p>

<pre><code class="language-text">索引键 → B-tree 叶子项 → TID (42, 7)
       → heap block 42 → line pointer slot 7 → tuple
</code></pre>

<p>Heap 直接取 pd_linp[slot - 1]. 一条 line pointer 占 4 字节, 普通槽的 lp_off 存 tuple 的字节偏移. 有了槽号, 各个索引可以直接定位 tuple, heap 页可以独立于索引的键顺序组织数据. HOT pruning 可以把根槽改成 LP_REDIRECT, 从这个槽进入同页的版本链. <a href="https://www.postgresql.org/docs/current/storage-page-layout.html">PostgreSQL 页布局</a> · <a href="https://www.postgresql.org/docs/current/storage-hot.html">HOT 说明</a></p>

<p>PageRepairFragmentation 压紧 tuple 字节区, 保留仍在使用的槽号. 移动 tuple 后, 更新原槽的 lp_off, 索引保存的 TID 继续有效. 有索引引用的死亡槽可以先保留为 LP_DEAD, 待 VACUUM 清理对应的索引项后转为 LP_UNUSED.</p>

<p>INSERT 可以复用中间的空槽和页内空闲字节. 槽号为 1, 2, 3 的三条记录, 删除槽 2 对应的 tuple 并完成安全回收后, 新记录可以使用槽 2, 原来槽 3 的记录继续使用原 TID. 连续位于槽数组尾部的空槽可以通过收缩 pd_lower 截掉.</p>

<p>普通 VACUUM 可以整理页内的 tuple 字节, 存活 tuple 仍使用原来的 TID. VACUUM FULL 持有目标表的 AccessExclusiveLock, 把存活行写到新的 heap, 再为新 TID 重建索引. <a href="https://www.postgresql.org/docs/current/routine-vacuuming.html">PostgreSQL VACUUM</a></p>

<p>这里很容易有一个问题, PostgreSQL 为什么不像 InnoDB 一样, 指向 page 就够了, 然后再 page 里面查找, 而需要一个 line pointer slot, 这样如果我对这个 page 做整理, 删除掉一些 page 里面的 record 以后, 这些 line pointer slot 顺序改变了以后, 这些 tid 也就也需要跟着修改了. 这样成本不是很大么? 并且这些 line pointer slot 永久都不能删除呢?</p>

<p>本质还是 pg 上面类似都是二级索引, 所以如果跳转到 heap 页上面需要遍历所有的 record 才可以找到匹配的, 而 mysql 是 pk 索引, 二级索引也是通过主键找到 pk, 然后再通过 pk 找对应的 record 的,  这样就不需要存具体位置, 因为已经按照 pk 排好序了.</p>

<h4 id="duckdb-的-rowid">DuckDB 的 rowid</h4>

<p>DuckDB 的 rowid 是一个 int64_t. RowIdColumnData 直接根据 RowGroup 起点和组内行序号生成这个虚拟列.</p>

<pre><code class="language-text">rowid = RowGroup.row_start + 组内行序号

ART(key) → rowid → 找覆盖该编号的 RowGroup
                 → rowid - RowGroup.row_start
                 → 对每列找 ColumnSegment
                 → 按段内行序号解码列值
</code></pre>

<p>一个 RowGroup 覆盖一段行编号范围, 各列可以存放在不同的 block. 组内行序号用来对齐各列. ColumnData::FetchRowsAtSegmentLevel 对每列按行号找 segment, 减掉 segment 起点后把段内行号交给 codec. 每个 segment 单独维护 block_id, block_offset 和压缩方式. <a href="https://github.com/duckdb/duckdb/blob/d54cbbe3df17e8e5ce68312f483b4155836112aa/src/storage/table/column_data.cpp#L783-L805">DuckDB 列内定位源码</a></p>

<p>列段重写可以重新分配 block, 改变压缩方式和段边界. 只要行编号保持原值, ART 就可以继续引用同一个 rowid. 连续且没有删除洞的 RowGroup 也可以合并, 保留原来的全表行编号.</p>

<p>UPDATE, DELETE 和 late materialization 都用 rowid 定位行. WAL 的删除和更新记录也带 rowid, 重放时用它找到目标位置. <a href="https://github.com/duckdb/duckdb/blob/d54cbbe3df17e8e5ce68312f483b4155836112aa/src/storage/write_ahead_log.cpp#L515-L535">WAL 写入源码</a></p>

<h4 id="duckdb-的-page-整理">DuckDB 的 page 整理</h4>

<p>DuckDB 的 DELETE 在 RowGroup 的版本信息里标记删除. 普通 INSERT 按 next_row_id 从表尾追加. 原有 rowid 为 0, 1, 2 时, 删除 1 再插入一行, 新行拿到 3, 表里可见的 rowid 为 0, 2, 3. 删除位置继续留在原组中. <a href="https://github.com/duckdb/duckdb/blob/d54cbbe3df17e8e5ce68312f483b4155836112aa/src/storage/data_table.cpp#L1055-L1064">追加位置的分配</a></p>

<p>DuckDB 通过 RowGroup 合并重写清理这些删除位置. Checkpoint 根据相邻候选组的活行数, 判断能否把存活行装进更少的新组. 调度条件是 target_count &lt; merge_count, 即输出组数少于输入组数. 删除越多, 活行就越容易装进更少的组, 具体任务还受容量, 尾部最小合并规模, max_vacuum_tasks 和索引策略约束. <a href="https://github.com/duckdb/duckdb/blob/d54cbbe3df17e8e5ce68312f483b4155836112aa/src/storage/table/row_group_collection.cpp#L1580-L1708">RowGroup 整理调度</a></p>

<p>一个部分删除的 RowGroup, 即使只剩很少的活行, 单组的 1 → 1 整理也不满足这个调度条件. 没有合适的邻组时, 删除洞会继续保留. 保留组仍可以重写列段和压缩 MVCC 版本信息. 全部删除的 RowGroup 则走单独的丢组路径, 是否能保留它留下的 rowid gap 取决于存储格式和索引维护策略. <a href="https://github.com/duckdb/duckdb/blob/d54cbbe3df17e8e5ce68312f483b4155836112aa/src/storage/table/row_group_collection.cpp#L1517-L1575">全删组处理</a></p>

<p>合并移除删除位置以后, 部分存活行可能得到新的行序号. 如果索引采用 REMAP 策略, DuckDB 收集实际改了编号的行, 对每个索引先删除旧 (key, rowid), 再插入新的引用. 其他策略可以重建索引, 或保留行编号并限制会改号的整理. <a href="https://github.com/duckdb/duckdb/blob/d54cbbe3df17e8e5ce68312f483b4155836112aa/src/storage/index_entry.cpp#L439-L454">ART remap 源码</a>
这也是在 DuckDB 里面如果有了 ART 索引以后, rowgroups 的整理就需要考虑对应的ART 指向的 rowid 也要修改了.</p>

<p>其实这里的设计和 PostgreSQL 是很像的, PostgreSQL 里面用 tid 指向 heap page 上的 heap number 和 line pointer, 区别的地方在于 PostgreSQL 在 page 整理的时候, 如果这个record 在这个 page 上面没有被删除, 那么它的 tid 是一直不会变的, 被删除的空间在经过 vacuum 以后会留给后续的写入复用, 所以上面对应的 index 就都不需要修改.
但是 DuckDB 的 checkpoint 的时候, 是有可能把相邻的 rowgroup 进行合并的, 那么合并以后这个记录所在的 rowid 就发生了变化了, 那么 ART Index 就必须跟着修改了.</p>]]></content><author><name>baotiao</name></author><category term="Other" /><summary type="html"><![CDATA[InnoDB 的二级索引通过主键回表. PostgreSQL 的 heap 索引引用 tid 包含 block number和line pointer, DuckDB 的 ART 引用表内row. 三种引擎在 page 整理时, 要维护各自的行引用和实际记录之间的对应关系.]]></summary></entry><entry><title type="html">CloudJump III Optimizing Cloud Databases for Tiered Storage(SIGMOD 2026)</title><link href="http://baotiao.github.io/2026/08/03/cloudjumpIII.html" rel="alternate" type="text/html" title="CloudJump III Optimizing Cloud Databases for Tiered Storage(SIGMOD 2026)" /><published>2026-08-03T00:00:00+00:00</published><updated>2026-08-03T00:00:00+00:00</updated><id>http://baotiao.github.io/2026/08/03/cloudjumpIII</id><content type="html" xml:base="http://baotiao.github.io/2026/08/03/cloudjumpIII.html"><![CDATA[<p>在云原生数据库的演进中, 计存分离让计算层和存储层可以独立扩展, 共享存储让多个计算节点访问同一份数据成为可能.</p>

<p>在《CloudJump: Optimizing Cloud Databases for Cloud Storages》(VLDB 2022) 中, 我们分析了存储介质从本地盘变成云存储之后, 数据库在 IO 路径上需要做的一系列重新设计;</p>

<p>在《CloudJump II: Optimizing Cloud Databases for Shared Storage》(SIGMOD 2025) 中, 我们提出 MVD (Multi-Version Data) 技术, 解决了共享存储架构下多计算节点的数据一致性问题.</p>

<p>沿着这条路线继续往前走, 一个自然的问题浮现出来:</p>

<p>云上的存储从来就不是单一介质, 而是一个天然的层级结构——从本地 NVMe SSD, 到网络块存储 ESSD, 再到几乎无限容量的对象存储 OSS, 每一层都处在成本、延迟、吞吐曲线上的不同位置.</p>

<p>如何让数据库真正利用好这个层级结构, 把热数据放在快的介质上, 把冷数据放在便宜的介质上, 同时保证性能稳定且不牺牲正确性, 这就是 CloudJump III 要回答的问题.</p>

<p>这篇论文已经发表在 2026 SIGMOD 上, 感兴趣的同学可以下载阅读:《CloudJump III: Optimizing Cloud Databases for Tiered Storage》</p>

<h4 id="云存储的天然层级">云存储的天然层级</h4>

<p>现代云数据库运行在一个层级化的存储体系之上. 以典型的云厂商产品为例, 各层的延迟和成本大致如下:</p>

<p><img src="https://raw.githubusercontent.com/baotiao/bb/main/uPic/image-20260805110807731.png" alt="image-20260805110807731" /></p>

<p>可以看到, 离计算越近的层级延迟越低、带宽越高, 但成本也越贵. 随着用户数据量的持续增长, 存储开销 (包括 DRAM) 已经成为数据库服务总拥有成本 (TCO) 的主要构成. 所以问题已经不是”要不要做分层”, 而是”如何做分层”: 在动态变化的 OLTP 负载下, 数据放置策略要如何保证性能和成本都稳定可控.</p>

<h4 id="现有分层方案的困境">现有分层方案的困境</h4>

<p>冷热分离的想法并不新, 业界已有大量实践: 主机侧的 NVMe 缓存 (dm-cache、bcache、LVM Cache), ILM/HSM 生命周期管理管道, 存储阵列和云服务的自动分层, 以及以对象存储为底座、只把最热的块留在 SSD 上的设计. 但这些方案有一个共同的特点: 它们都工作在数据库内核之外——块层、文件系统层或者网关层. 它们能观察到 IO 模式, 却看不到存储引擎的内部状态, 而这恰恰是正确、高效分层的关键. 在内核之外分层会造成系统性的误判:</p>

<ol>
  <li>最热的页面常驻在 DRAM Buffer Pool 中, 几乎不产生外部 IO, 在基于 IO trace 的分析中反而显得”冷”;</li>
  <li>结构上重要的索引页、元数据页会被过早地降级到慢介质;</li>
  <li>ILM/HSM 的粒度太粗, 一个小的读取会触发整个文件或大 extent 的召回 (recall), 周期性的批量迁移又会和前台 IO 争抢带宽, 引发召回风暴;</li>
  <li>分层的数据移动和内核的恢复、备份协议是解耦的, 不与 LSN 语义、快照协议协同, 零停机场景下的正确性很难保证.</li>
</ol>

<p>分层之后, 每一次快层 miss 的代价是残酷的: 目标页要么暂时不可用, 要么必须同步地从慢几个数量级的层级取回, 给查询注入不可控的抖动. 手工的时间分区、表级重组都是粗粒度且被动的, 跟不上分钟级的负载变化.</p>

<p>所以运维侧真正需要的, 是一种既保留多层存储性能成本收益, 又能约束 miss 代价、不增加运维脆弱性的分层机制.</p>

<h4 id="cloudjump-iii-引擎集成的分层设计">CloudJump III: 引擎集成的分层设计</h4>

<p>CloudJump III 的核心思路是把分层决策搬进存储引擎内部, 在 Buffer Manager 的天然控制点 (eviction 和 flush) 上做数据放置决策, 利用引擎可见的元信息——页类型和存活时间、页表关系和配额、临时表识别、脏页状态、Buffer Pool 驻留情况——来决定数据的准入和写入路由. 这个设计我们称之为 eviction-centric、engine-aware.</p>

<p>整体架构划分成四层, 并明确了缓存层 (易失) 与存储层 (持久) 的边界:</p>

<p><img src="https://raw.githubusercontent.com/baotiao/bb/main/uPic/image-20260805110741707.png" alt="image-20260805110741707" style="zoom:67%;" /></p>

<ol>
  <li><strong>InnoDB Buffer Pool (DRAM)</strong>: 传统的内存缓存, 持有热页, 在 eviction/flush 这些天然控制点上触发分层决策;</li>
  <li><strong>Buffer Pool Extension (BPE, 本地 SSD)</strong>: Buffer Pool 的只读扩展, 只缓存干净页, 属于易失的缓存层, 丢失不影响持久性;</li>
  <li><strong>OSS Buffer (ESSD)</strong>: 存储层的前端, 接受页面刷脏的写入, 把页粒度的更新聚合成块级写入, 在数据被同步到远端之前先在这里持久化, 既降低写放大, 也把对象存储与小随机 IO 隔离开;</li>
  <li><strong>OSS 对象存储</strong>: 最终的持久层, 低成本、容量无限, 通过 HTTP PUT/GET 访问.</li>
</ol>

<p>读路径是一个层级化的流水线: DRAM → BPE → OSS Buffer → 远端 OSS, 逐层回退, 命中后向上提升 (promotion).</p>

<p>写路径则是一个多阶段的管道: Buffer Pool 刷脏先落到 OSS Buffer 对应的 ESSD 上 (近端持久化), 之后由后台线程把脏页合并成 2 MB 的对象, 以 append-only 的版本化方式异步 PUT 到远端 OSS. 每张 OSS-backed 表被逻辑切分成固定大小的 2 MB 对象 (128 个 16 KB 页), OSS Buffer 为每个对象分配一个 block, 内部结构参考 InnoDB Buffer Pool 的页管理逻辑: page-to-block hash 做快速查找, LRU 做替换, flush list 追踪待写回 IO.</p>

<h4 id="bpe-基于-s3-fifo-的准入策略">BPE: 基于 S3-FIFO 的准入策略</h4>

<p>本地 SSD 作为 Buffer Pool 的扩展缓存, 最大的敌人是缓存污染: 大量只被访问一次的页 (one-hit wonder) 被无差别写入 SSD, 既浪费写寿命, 又挤占了真正可复用页的空间. BPE 的设计借鉴了 S3-FIFO 的选择性准入和 second-chance 思想:</p>

<p>在 DRAM Buffer Pool 中, 传统的 young/old 双链表之外增加一个 <strong>ghost 链表</strong>, 只记录最近被淘汰页的 ID (纯元数据, 不含数据). 页从 old 链表淘汰时先进入 ghost; 只有当它在 ghost 中被再次访问, 证明了自己的复用价值, 才会被提升进 BPE 的 SSD 空间. 这个延迟的、基于复用验证的准入机制, 天然过滤掉了 one-hit 页. BPE 内部则采用改良的 CLOCK 替换算法, 用环形指针和 second-chance bit 替代 LRU 链表, 降低同步开销的同时让淘汰顺序对齐 SSD 布局, 实现顺序写、减少磨损.</p>

<p>消融实验里这个策略的效果很直接: 相比 full-admit (全部准入), ghost 准入策略把 TPS 提升了 12%, 命中率从 63.4% 提升到 72.7%, 而 BPE 的 IOPS 从 22369 降到 2082, 下降约 91%——更少的细粒度写入, 更平稳的写回.</p>

<p>工程上 BPE 还有两个值得一提的细节: 一是元数据压缩, 64 GB 的 BPE 实例只需要约 184 MB 的控制元数据, 且消除了 per-page 的锁结构; 二是 chunk-based resizing, BPE 空间按 64 MB 的 chunk 划分, 可以秒级在线增减, 热点实例可以临时扩容缓存, 用完释放, 不需要重启.</p>

<h4 id="oss-buffer-写合并与-crash-consistency">OSS Buffer: 写合并与 crash consistency</h4>

<p><img src="https://raw.githubusercontent.com/baotiao/bb/main/uPic/image-20260805165827221.png" alt="image-20260805165827221" /></p>

<p>OSS Buffer 的职责是把数据库的页级写入转换成对象存储友好的块级写入. 脏块的刷写走一个三阶段的异步流水线:</p>

<p>先更新块级元数据 (记录版本、标记 in-flight), 再把块内脏页合并成连续的 2 MB 段异步 PUT 到 OSS (每次刷写携带单调递增的版本号), 成功后块状态从 Dirty 转为 Clean 进而 Free.</p>

<p>这里的关键是 crash consistency 的保证. 同一个逻辑页可能同时存在于内存、BPE 和 OSS Buffer 中, CloudJump III 通过一组互补的写序约束保证可恢复性: <strong>本地写入时, 元数据先于数据更新</strong> (记录意图); <strong>远端同步时, 数据先传输, 元数据后标记 clean</strong>. 这种交叉的顺序设计保证了任何一个块要么完整持久, 要么可以安全重放——元数据更新了但数据缺失, 恢复时重放 redo; 数据在但元数据陈旧, 重新刷写即可, 两条路径都是幂等的.</p>

<p>刷写调度上结合了批量聚合、时间延迟 (避免热块反复写)、水位监控和限速 (在 OSS QPS 和多租户公平性约束下调节吞吐). 干净块只有在 OSS 同步完成后才成为淘汰候选, 保证空间复用永远发生在持久化之后.</p>

<h4 id="快照版本与零停机备份">快照版本与零停机备份</h4>

<p><img src="https://raw.githubusercontent.com/baotiao/bb/main/uPic/image-20260805165812162.png" alt="image-20260805165812162" /></p>

<p>分层之后, 备份和恢复的正确性是最容易被忽视也最容易出问题的地方.</p>

<p>CloudJump III 用一个快照版本协议把分层状态的演进和备份协同起来. 系统维护一个全局的 next_snapshot_version, 备份开始时短暂加锁、递增版本号, 之后所有 OSS 写入都携带这个版本; 对每个 2 MB 对象, 如果在新快照纪元之后被修改, 则写出一个新版本的对象 (如 file_0002_v2), 旧版本保留给备份读取. 每张表维护一个 .meta 文件, 记录每个块的 dirty bit 和版本号, 增量备份只复制自上次备份以来变化的对象.</p>

<p>备份流程走 lock–version–copy 的序列: 锁定元数据固定版本视图, 递增快照计数, 然后通过 OSS 的 fast-copy API 做桶内影子拷贝——fast-copy 只复制对象元数据不搬数据, 所以即使是数 TB 的表, 快照创建也在秒级完成.</p>

<p>实测数据: CloudJump III 的快照创建耗时 0.64 秒, 接近纯 ESSD 的 0.52 秒, 远快于纯 OSS 路径的 53.73 秒, 而备份和恢复总时长与 OSS baseline 持平 (瓶颈在远端带宽, 分层本身没有引入额外开销).</p>

<h4 id="实验结果">实验结果</h4>

<p>我们在两种规格上评估了 CloudJump III: 小规格 (8 核、1 GB Buffer Pool、50 GB 数据) 和大规格 (64 核、100 GB Buffer Pool、5 TB 数据), 快层容量覆盖数据集的 5% 到 50%, 负载包括 Sysbench、YCSB (Zipf 偏斜 0.8–2.0)、Voter 以及一个来自阿里云线上游戏客户的真实负载 (大 BLOB 更新 + 突发写入).</p>

<p>几个有代表性的结论:</p>

<ol>
  <li>TPS 随缓存比例和偏斜度单调上升, 在热数据能装进快层时出现明显的拐点. 中等偏斜 (Zipf α ≥ 1.4) 下, 20%–30% 的缓存比例就能逼近全 ESSD 的吞吐上界, 而单位成本的性能 (CP) 显著更高;</li>
  <li>Voter 负载在 64 线程下维持全 ESSD 吞吐的 79%–80%, 游戏负载则全程保持在 baseline 的 ±5% 以内, 在中等并发下甚至反超 3%–4%——大写入直接 bypass 到 ESSD 避免争抢共享刷写队列, 小更新由 OSS Buffer 合并成 2 MB 对象平滑带宽需求;</li>
  <li>消融实验验证了各机制的贡献: ghost 准入 (+12% TPS, −91% BPE IOPS)、临时表排除 (短时分析型突发不再冲击远端存储带宽)、DDL/BLOB bypass (消除了 DDL 阶段前台吞吐的深度下跌).</li>
</ol>

<h4 id="一些经验">一些经验</h4>

<p>三年的线上部署给了我们一些超出论文本身的体会:</p>

<p><strong>快层应该是共享缓存, 而不是专属存储.</strong> 按表刚性划分快层容量会导致容量利用低效和性能不稳定. CloudJump III 把快层重新解释为全局共享的缓存, 由统一的淘汰和配额策略治理, 逻辑归属和物理放置解耦, 容量随负载动态分配.</p>

<p><strong>Eviction-centric 优于主动迁移.</strong> 依赖预测模型和后台控制器搬数据的架构, 工程代价远比理论收益大: 迁移线程引入独立的锁层级, 和 Buffer Pool 锁交互可能死锁; 迁移和前台查询的带宽仲裁在突发时容易饿死一方; 迁移中途 crash 的恢复需要额外的处理路径, 复杂化 redo/undo 逻辑. 把放置决策限制在 eviction 和 flush 这两个天然控制点上, 复用现有的 Buffer Manager 控制路径, 不引入额外同步, 运维人员面对的是一个单一的、被充分理解的控制回路.</p>

<p><strong>分层必须和恢复、备份协议协同.</strong> 脱离恢复逻辑的独立数据移动, 只更新元数据而没有事务上下文, crash 后可能出现页面重复或丢失. CloudJump III 让放置变化只影响页面的物理位置, 与 LSN 标识的逻辑版本完全正交——这类正确性风险在测试中往往暴露不出来, 到了生产环境才会以严重故障的形式出现.</p>

<h4 id="总结">总结</h4>

<p>从 CloudJump I 的 IO 路径重构, 到 CloudJump II 的 MVD 多版本共享存储, 再到 CloudJump III 的引擎集成分层, 这条线索的内核是一致的: 基于标准云存储服务构建云原生数据库的存储底座, 把复杂度留在计算层/引擎层, 让存储层保持简单和通用, 这也是解耦数据库/存储层的好处, 对比 Aurora 的架构, CloudJump 可以充分享受到存储层的发展带来的收益, 而不需要开发自己的 Page Server 层去对接不同的存储介质.</p>

<p>CloudJump III 证明了在分层存储上获得可预期的性能, 关键在于把分层放进和缓存、恢复同一个控制回路里——用引擎可见的方式做准确的放置, 用 eviction-centric 的机制约束 miss 的代价, 用快照版本协议保证零停机备份的正确性. 最终的效果是: 用一小部分快层容量, 换来接近本地盘的吞吐和稳定的访问延迟, 以及显著更优的单位成本性能.</p>

<p>更多的内容可以参考论文:《CloudJump III: Optimizing Cloud Databases for Tiered Storage》.</p>

<h4 id="相关论文">相关论文</h4>

<p>Chen, Z., Sha, M., Li, F., Wang, S., Huang, B., Ma, G., … &amp; Wang, Y. (2026). CloudJump III: Optimizing Cloud Databases for Tiered Storage. In Proceedings of the 2026 International Conference on Management of Data (SIGMOD).</p>

<p>Chen, Z., Yang, X., Sha, M., Li, F., Wang, K., Miao, Z., … &amp; Wang, S. (2025, June). CloudJump II: Optimizing Cloud Databases for Shared Storage. In Companion of the 2025 International Conference on Management of Data (pp. 336-349).</p>

<p>Chen, Z., Yang, X., Li, F., Cheng, X., Hu, Q., Miao, Z., … &amp; Wang, S. (2022). CloudJump: optimizing cloud databases for cloud storages. Proceedings of the VLDB Endowment, 15(12), 3432-3444.</p>]]></content><author><name>baotiao</name></author><category term="Other" /><summary type="html"><![CDATA[在云原生数据库的演进中, 计存分离让计算层和存储层可以独立扩展, 共享存储让多个计算节点访问同一份数据成为可能.]]></summary></entry><entry><title type="html">PostgreSQL HeapTable + Pin vs MySQL InnoDB IOT + Persist cursor</title><link href="http://baotiao.github.io/2026/05/28/pg-pin-innodb-pcur.html" rel="alternate" type="text/html" title="PostgreSQL HeapTable + Pin vs MySQL InnoDB IOT + Persist cursor" /><published>2026-05-28T00:00:00+00:00</published><updated>2026-05-28T00:00:00+00:00</updated><id>http://baotiao.github.io/2026/05/28/pg-pin-innodb-pcur</id><content type="html" xml:base="http://baotiao.github.io/2026/05/28/pg-pin-innodb-pcur.html"><![CDATA[<p>前面介绍过 PostgreSQL Buffer Access 5 Rules 里面的 Pin 机制, 其实 HeapTable + Pin 机制还带来了其他和 InnoDB 的区别.</p>

<p>InnoDB Persist cursor 是用来保留查询遍历 btree 过程中 index tree cursor 的位置.</p>

<p>为什么需要 persist cursor?</p>

<p>因为有多种场景下, 比如在执行大查询时, 查到一行以后, 需要将数据返回给 server 层处理. 这时, 你不能在返回指向 Record 的指针 index tree cursor 后依然持有该 Page 的锁 (Latch).</p>

<p>如果锁不放开, 在上层处理数据的期间, 这个 Page 就无法被修改.</p>

<p>如果锁放开, 这个 Page 有可能被修改了, 那么指向 Record 的指针就失效了, 需要重新定位这个 index tree cursor.</p>

<p>所以有了 btr_pcur_restore_position() 这个操作, 对应的把 pcur position 保存下来的操作就是 store_position() 操作</p>

<p>比如在 row_ins_clust_index_entry_low, row_upd_sec_index_entry_low 这些路口函数里面, 都需要申请</p>

<p>btr_pcur_t pcur;</p>

<p>然后通过 btr_pcur_open(index, entry, PAGE_CUR_LE, mode, &amp;pcur, &amp;mtr);</p>

<p>把 pcur 指向 btree 的指定位置</p>

<p>可以认为, InnoDB 的 Persistent Cursor 设计和 PostgreSQL 的 Heaptable + Pin 机制走了两条不同的路.</p>

<p>我们都会遇到一个问题: 在执行大查询时, 查到一行以后, 需要将数据返回给上层处理. 这时, 你不能在返回指向 Record 的指针后依然持有该 Page 的锁 (Latch). 如果锁不放开, 在上层处理数据的期间, 这个 Page 就无法被修改.</p>

<p>因此, MySQL InnoDB 的做法是:</p>

<ol>
  <li>保存位置: 将当前查到的位置记下来. 比如在一个大查询中, 为了方便找下一个 Record, 最好把 Record 位置信息保存下来. 这样在读下一行时, 就不需要重新自上而下地遍历 B-Tree, 而是直接根据保存的信息找到 Next Record 即可.</li>
  <li>处理变更: 虽然保存了位置, 但你不能阻止别人对这个 Page 进行修改. 最直观的想法就是先保存位置, 等上层处理完后再处理下一个 Record.
    <ul>
      <li>绝大部分情况下, Record 在 Page 上的位置没有发生改变, 那么直接处理下一行即可.</li>
      <li>如果位置发生了改变, 就重新遍历 B-Tree, 找到 Record 在新的 Page 上的位置, 然后再进行下一次查找. 对应的就是代码里面 restore_position() 逻辑</li>
    </ul>
  </li>
</ol>

<p>所以 InnoDB 的逻辑很符合直观: 读完一行并返回给上层处理期间, 把 Page 的锁放掉, 允许其他事务对该 Page 进行修改. 当要处理下一行数据时, 判断 Page 是否被修改过: 如果没有修改, 就复用位置信息; 如果修改了, 就重新走一遍遍历 B-Tree 的逻辑.</p>

<p>相比之下, PostgreSQL 的 Heaptable + Pin 机制走了另一条路. 它保证 Record 所在的 Page 位置不会发生改变. 通过给 Page 加一个 Pin 约束, 如果有人想修改 Page (比如进行整理, 重组等操作), 只要该 Page 被 Pin 住, 就不允许发生 Record 位置的偏移.</p>

<p><strong>InnoDB IOT 对比 PostgreSQL HeapTable</strong></p>

<ul>
  <li>InnoDB IOT: Record 的修改是 In-place Update (原地更新), 老版本记录在 Undo Log 里. 即使是更新操作, Record 的位置也有可能发生改变.</li>
  <li>PostgreSQL HeapTable: 在一个 Page 内部, Tuple (即 Record) 是 Append-only 的, 不做原地更新. 如果 Page 内有修改, 它不会修改旧值, 而是不断向后追加. 只有在 Vacuum 这种批量操作或者对 Page 进行整理时, 才会修改 Record 在 Page 上的物理位置.</li>
</ul>

<p>由于 PostgreSQL 这种位置修改的频率是批量的, 没有 MySQL 那么频繁, 所以它选择了另外一条路: 把 Record 的位置定住. 如果后台 Vacuum 发现这个 Page 被 Pin 住了, 就跳过它, 直接去处理下一个 Page.</p>

<p>总结来看, 选择这两套策略主要有以下原因:</p>

<ol>
  <li>更新机制: MySQL InnoDB IOT 以 In-place Update 为主, 而 PostgreSQL HeapTable 在 Page 层面是 Append-only 的.</li>
  <li>逻辑复杂度: 理论上, MySQL 的实现更复杂一点, 但更符合逻辑, 因为它不会因为一个查询操作就导致 Page 无法进行整理或重组; 而 PostgreSQL 的实现则相对简单一些.</li>
</ol>

<p>PostgreSQL 的 Heaptable + Pin 和 InnoDB 的 Persist Cursor 机制相比, 带来的一个优势是可以做到全链路的读取不需要拷贝.</p>

<p><strong>InnoDB 读路径上的拷贝</strong></p>

<p>比如在最常见的 row_search_mvcc 里面</p>

<p>row_search_mvcc 的核心序列是这样:</p>

<pre><code>1. latch 住 leaf page
2. cursor 定位到 record, 拿 rec_t 裸指针
3. MVCC 可见性判断
4. 还持着 latch 的时候, 调 row_sel_store_mysql_rec, 把 record 转成 MySQL row format, copy 到 prebuilt-&gt;row_buf
5. 释放 latch (或 btr_pcur_store_position 存位置)
6. 把 row 返回 server
</code></pre>

<p>关键在第 4 步和第 5 步的顺序: InnoDB 是先 copy 出来, 才释放 latch. copy 出来是为了尽快可以把 page latch 释放掉, 减少锁的占用.
  一旦 latch 放掉, buffer 里那条 record 随时可能被改 / 搬走, 所以必须趁还持 latch, 先把数据 copy 到一块 latch 之外的内存 (row_buf), 之后才敢放 latch.</p>

<p>这里即使不存在 MySQL row format 和 InnoDB row format 格式不一致的问题, 也需要有这样的拷贝, 核心还是因为这个 Page latch 释放了以后, 这个 pcur 存的 record 的内容有可能被 inplace update.</p>

<p>之前跑 TPCC 的经验, 在 oltp_readonly 没有明显热点的场景下, 这里的内存拷贝是一个瓶颈点.</p>

<p><strong>PostgreSQL 读路径上的拷贝</strong></p>

<p>没有. heap_getnextslot 返回的 slot 里挂 BufferHeapTuple, t_data 直接指 buffer 字节; executor 节点之间传 slot 不 copy; 访问列走 heap_getattr 直接解 t_data 后面的字节. visibility check 找到哪个版本可见, 就读那条 tuple 的 t_data, 老版本本来就在 heap 里原地, 不需要重建.</p>

<p>只有显式物化点才 copy: Sort / HashJoin build / Material 节点进 tuplestore, WITH HOLD cursor 在 commit 时物化, trigger 访问 OLD/NEW, TOAST 列 detoast, 以及最终发给客户端. 单一 SELECT 链条上的过滤, 投影, join 不 copy.</p>

<p>当然 Pin 不是白来的. reader 持 pin 期间, vacuum 在那个 page 上拿不到 cleanup lock, 该 page 的物理整理被推迟 (page 级, non-aggressive vacuum 跳过即可). 另外老版本堆在 heap 里, 要靠 vacuum 回收. PG 用读路径的零拷贝换来了 vacuum 这一侧的负担.</p>]]></content><author><name>baotiao</name></author><category term="Other" /><summary type="html"><![CDATA[前面介绍过 PostgreSQL Buffer Access 5 Rules 里面的 Pin 机制, 其实 HeapTable + Pin 机制还带来了其他和 InnoDB 的区别.]]></summary></entry><entry><title type="html">PostgreSQL Buffer Access 5 Rules</title><link href="http://baotiao.github.io/2026/05/19/pg-buffer-pin-protocol.html" rel="alternate" type="text/html" title="PostgreSQL Buffer Access 5 Rules" /><published>2026-05-19T00:00:00+00:00</published><updated>2026-05-19T00:00:00+00:00</updated><id>http://baotiao.github.io/2026/05/19/pg-buffer-pin-protocol</id><content type="html" xml:base="http://baotiao.github.io/2026/05/19/pg-buffer-pin-protocol.html"><![CDATA[<p>src/backend/storage/buffer/README 是 PG 社区维护 buffer manager 的官方设计文档. 它在开头列了 5 条 buffer access rules, 提 patch / review 时直接引用. 这 5 条规则合起来定义了 PG 的 Pin 协议, 也是 PG 和 InnoDB buffer manager 设计上真正分叉的地方.</p>

<h4 id="同步原语先看清楚">同步原语先看清楚</h4>

<p>PG 的 buffer 上有两个独立的同步原语:</p>

<ul>
  <li>Pin — atomic refcount, 防止 slot 被 evict 换成别的 page. 持有时间可长可短, 甚至跨函数 / 跨节点传递都行.</li>
  <li>Content Lock — LWLock, share / exclusive 两种模式, 保护 page 字节内容的并发访问. 持有时间应当尽量短.</li>
</ul>

<p>PG 的关键设计选择是: 这两个原语可以脱钩. 拿到一个 buffer 之后, pin 和 content lock 是分别 acquire / release 的, 中间可以出现 “只持 pin 不持 content lock” 这种状态, 而且这种状态在 OLTP 主流路径里到处都是.</p>

<p>后面 5 条规则全是在 “pin / content lock 怎么组合使用” 这个空间里画出几条边界.</p>

<h4 id="rule-1-访问-tuple-的基本条件">Rule 1: 访问 tuple 的基本条件</h4>

<blockquote>
  <p>To scan a page for tuples, one must hold a pin and either shared or exclusive content lock.</p>
</blockquote>

<p>要访问一个 page 上的 tuple, 必须同时持有 pin + content lock (share 或 exclusive 都行). 这是基线, 后面 4 条规则都是在这个基线上做加减.</p>

<h4 id="rule-2-pin-保证-tuple-物理位置稳定">Rule 2: Pin 保证 tuple 物理位置稳定</h4>

<blockquote>
  <p>Once one has determined that a tuple is interesting (visible to the current transaction) one may drop the content lock, yet continue to access the tuple’s data for as long as one holds the buffer pin. Therefore the tuple cannot go away while the pin is held (see rule #5). Its state could change, but that is assumed not to matter after the initial determination of visibility is made.</p>
</blockquote>

<p>这条是 Pin 协议里最有意思的一条. 它明确允许这种状态 — 只持 Pin, 不持 Content Lock.</p>

<p>在这个状态下, tuple 的物理位置 (line pointer + tuple bytes 在 page 内的偏移) 保证不变. 所以上层代码可以拿着 HeapTuple 这样的 in-buffer 裸指针跨函数 / 跨执行节点传递, 只要 Pin 还在就一直有效.</p>

<p>这个保证不是 Pin 自己提供的, 是 Pin 通过 Rule 5 间接提供的. Pin 本身只阻挡 slot 被换 page, 阻挡不了 page 内的物理整理. 但是物理整理 (HOT prune / vacuum / PageRepairFragmentation) 需要 cleanup lock, 而 cleanup lock 要求 refcount = 1, 所以只要我还持 Pin, 没人能进来搬 tuple.</p>

<p>“Its state could change, but that is assumed not to matter after the initial determination of visibility is made” 的意思是:</p>

<ol>
  <li>Visibility check 在持 content lock 期间已经做完, 决策已经定. 后续即使 hint bit / xmin / xmax 被并发改, reader 不会回头重做 visibility check.</li>
  <li>Tuple 的 data payload 不会变, 因为 PG 是 immutable tuple — UPDATE 不是原地改, 是删一个 + 插一个新的. Reader 通过 t_data 后续访问 payload 拿到的值跟做 visibility check 那一刻的是同一个 tuple 实体.</li>
  <li>物理位置不变, 由 Pin 通过 Rule 5 保证.</li>
</ol>

<p>三件事合起来才让 “释放 content lock 之后继续用 t_data 访问 tuple” 是安全的.</p>

<p><strong>带来的副作用: page 级的 cleanup lock 竞争</strong></p>

<p>backend 在只持 Pin、不持 content lock 的状态下继续引用 buffer 里的 tuple 时, vacuum 在同一个 page 上拿不到 cleanup lock (Rule 5 要 refcount = 1). 这个影响是 page 级的, 只影响当前被 pin 的那个 page 的物理整理 (prune / freeze / defrag).</p>

<p>Non-aggressive vacuum 拿不到 cleanup lock 时降级走 lazy_scan_noprune, 跳过这个 page 的 prune / freeze, 不等待:</p>

<blockquote>
  <p>A non-aggressive vacuum may choose to skip pruning and freezing if it cannot acquire a cleanup lock on the buffer right away. In this case, it may miss cleaning up dead tuples and their associated index entries (though it is free to reap any existing dead items on the page).</p>
</blockquote>

<p>只有需要推进 freeze horizon 的 aggressive vacuum 才必须等 cleanup lock — 它不能跳过待 freeze 的 page (跳了 relfrozenxid 就推进不了).</p>

<p>长事务对 vacuum 的整表影响 (整表 dead tuple 收不掉, bloat 涨) 走的是另一条路径: 老事务的 backend_xmin 卡住 MVCC horizon, dead tuple 在 vacuum 眼里还不算 dead. 这跟 buffer pin 是两件独立的事, 不要混在一起.</p>

<h4 id="rule-3-修改-header-多字段必须持-exclusive-content-lock">Rule 3: 修改 header 多字段必须持 exclusive content lock</h4>

<blockquote>
  <p>To add a tuple or change the xmin/xmax fields of an existing tuple, one must hold a pin and an exclusive content lock on the containing buffer. This ensures that no one else might see a partially-updated state of the tuple while they are doing visibility checks.</p>
</blockquote>

<p>Rule 3 解决的不是 “指针已经传给上层” 的问题 (那是 Rule 2). Rule 3 解决的是 visibility check 的多字段一致性.</p>

<p><strong>为什么是多字段问题</strong></p>

<p>PG 的 visibility check (HeapTupleSatisfiesVisibility 系列) 是一个读多个字段然后组合判断的过程, 典型路径要读:</p>

<ul>
  <li>t_xmin (32 bit)</li>
  <li>t_xmax (32 bit)</li>
  <li>t_infomask (flag 集合)</li>
  <li>t_infomask2</li>
  <li>t_ctid (跟 HOT chain 时)</li>
</ul>

<p>判断逻辑是 “xmin 提交了吗? xmax 提交了吗? 在我的 snapshot 范围内吗? 是 lock-only 的 xmax 还是真删除? 是 HOT update 吗?” — 这些字段必须作为一个整体保持一致, 否则会得出错误的可见性结论.</p>

<p><strong>具体场景</strong></p>

<p>T1 在做 HOT update, 要修改老 tuple X 的几个字段:</p>

<pre><code>写入 1: t_xmax    = T1.xid           /* 标记 X 被 T1 删 */
写入 2: t_infomask 加 HEAP_HOT_UPDATED + 调整 lock 信息
写入 3: t_ctid    = new_tid          /* 指向 HOT 链下一版本 */
</code></pre>

<p>如果 T2 (reader) 持 share content lock 就能进来做 visibility, 可能撞到这个序列中间:</p>

<pre><code>T1 已写 t_xmax = T1.xid              ← 这一步做完
T1 还没写 t_infomask / t_ctid        ← 还没做
T2 进来 visibility check:
   读 t_xmin = 老的, committed       → 之前可见
   读 t_xmax = T1.xid, in-progress   → "正在被 T1 删"
   读 t_infomask                     → HEAP_HOT_UPDATED 没设
   读 t_ctid                         → 还是老的 (指自己)
   结论: "这是一个被删的 tuple, 不是 HOT 链头" → 不跟随 HOT
   返回错误结果, 看不到 T1 的新版本
</code></pre>

<p>任何写顺序都有类似的中间状态. Exclusive content lock 就是堵这个窗口.</p>

<p><strong>Rule 2 vs Rule 3 的分工</strong></p>

<p>把两条规则放一起看:</p>

<table>
  <thead>
    <tr>
      <th> </th>
      <th>保护对象</th>
      <th>同步原语</th>
      <th>解决的问题</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Rule 2</td>
      <td>tuple 的物理位置</td>
      <td>Pin (通过阻挡 cleanup lock)</td>
      <td>上层裸指针在 Pin 期间继续 deref</td>
    </tr>
    <tr>
      <td>Rule 3</td>
      <td>tuple header 的多字段一致性</td>
      <td>Exclusive content lock</td>
      <td>reader 不读到 writer 半完成的 header 状态</td>
    </tr>
  </tbody>
</table>

<p>两条规则保护的是正交的两件事. 一个典型协作场景:</p>

<ul>
  <li>BTree 索引扫描读完 tuple, 释放 content lock, 保留 Pin (Rule 2 生效)</li>
  <li>这时另一个 backend 拿 exclusive content lock 去改这个 tuple 的 xmax (合法, Rule 3 满足)</li>
  <li>但它做不了 HOT prune (Rule 5 要 refcount = 1, 我还 Pin 着)</li>
  <li>索引扫描手上的 t_data 仍指向同一段字节 (Rule 2)</li>
  <li>期间 tuple header 被改 — 没关系, 索引扫描早就做完了 visibility check, 后续只访问 immutable 的 payload</li>
</ul>

<p>这套分工让 PG 的 reader 能把重的同步 (content lock) 控制在最短时间, 轻的同步 (Pin) 可以长持有.</p>

<h4 id="rule-4-hint-bit-可以在-shared-lock-下-or">Rule 4: hint bit 可以在 shared lock 下 OR</h4>

<blockquote>
  <p>It is considered OK to update tuple commit status bits (i.e. OR the values HEAP_XMIN_COMMITTED, HEAP_XMIN_INVALID, HEAP_XMAX_COMMITTED, HEAP_XMAX_INVALID into t_infomask) while holding only a shared lock and pin on a buffer. This is OK because another backend looking at the tuple at about the same time would OR the same bits into the field, so there is little or no risk of conflicting update; what’s more, if there did manage to be a conflict it would merely mean that one bit-update would be lost.</p>
</blockquote>

<p>Rule 4 是 Rule 3 的一个特例放宽: 在 4 个特定的 hint bit 上, 允许只持 shared lock + Pin 就改 (用 OR 操作). 这条放宽不是简单因为 “是单字段”, 而是因为 hint bit 满足四个性质同时成立.</p>

<p><strong>性质一: 写的是单 bit, 方向单一 (只置位)</strong></p>

<pre><code class="language-c">tuple-&gt;t_infomask |= HEAP_XMIN_COMMITTED;   /* 单 bit OR */
</code></pre>

<p>跟 Rule 3 写 4 byte 的 t_xmin = 12345 是完全不同的事. 单 bit OR 不存在多 byte 撕裂的问题, 也不存在 “A 想置 1, B 想置 0” 的方向冲突.</p>

<p><strong>性质二: 操作幂等</strong></p>

<p>所有 backend 想 set 同一个 hint bit 的内容都一样, 因为来源是同一个 CLOG 查询结果:</p>

<ul>
  <li>HEAP_XMIN_COMMITTED: 当 xmin 这个 txn 在 CLOG 里查到 committed 时才会去 OR. CLOG 查询结果是确定的, 任何 backend 查都查到同一个答案</li>
  <li>其它三个同理</li>
</ul>

<p>多个并发 OR 同一个 bit 的最终结果 = 单个 OR. Idempotent.</p>

<p><strong>性质三: Hint bit 是 cache, 不是权威</strong></p>

<p>这条最关键. Hint bit 的语义是 “CLOG 查询结果的缓存”, visibility 真正的兜底是 CLOG:</p>

<pre><code class="language-c">/* 简化的 visibility check */
if (tuple-&gt;t_infomask &amp; HEAP_XMIN_COMMITTED) {
    /* fast path: hint bit 说 committed, 信它 */
} else if (tuple-&gt;t_infomask &amp; HEAP_XMIN_INVALID) {
    /* fast path: hint bit 说 aborted, 信它 */
} else {
    /* slow path: 查 CLOG */
    if (TransactionIdDidCommit(xmin)) {
        tuple-&gt;t_infomask |= HEAP_XMIN_COMMITTED;  /* 顺手设上 hint bit */
    }
}
</code></pre>

<p>即使 hint bit 没设, visibility check 也不会得错, 只是慢一点. 跟 Rule 3 保护的 t_xmin / t_xmax (读错就直接错) 性质完全不同.</p>

<p><strong>性质四: 丢失 OR 操作可接受</strong></p>

<p>如果两个 backend 同时 OR 同一个 bit, 在 16-bit OR 不真正原子的极端情况下, 可能其中一个 OR “丢了”. 但这没关系 — 下一次 visibility check 进 slow path, 重新查 CLOG, 再尝试设 hint bit. README 原话: “one bit-update would be lost” — PG 直接承认会丢, 但丢得起.</p>

<p><strong>四条性质必须全部满足</strong></p>

<p>t_infomask 里不是所有 bit 都满足这四条性质. 比如:</p>

<ul>
  <li>HEAP_HOT_UPDATED: 决定要不要跟 HOT chain, 是权威的, 不是 cache, 必须走 Rule 3 用 exclusive lock</li>
  <li>HEAP_XMAX_LOCK_ONLY: 决定 xmax 是真删除还是只 lock, 权威, 必须 exclusive</li>
  <li>HEAP_KEYS_UPDATED, HEAP_XMAX_IS_MULTI: 同样权威, 必须 exclusive</li>
</ul>

<p>所以 Rule 4 明确列了只有那四个 hint bit (XMIN/XMAX × COMMITTED/INVALID) 适用, 其它 bit 一律走 Rule 3.</p>

<p><strong>Freeze tuple 的例外</strong></p>

<p>同时设置 HEAP_XMIN_INVALID 和 HEAP_XMIN_COMMITTED (= HEAP_XMIN_FROZEN) 表示 freeze 一个 tuple. 它用的是 Rule 4 那四个 hint bit 里的两个, 但不走 Rule 4 的 best-effort OR 路径. README 明确说:</p>

<blockquote>
  <p>Note, however, that a tuple is frozen by setting both HEAP_XMIN_INVALID and HEAP_XMIN_COMMITTED; this is a critical update and accordingly requires an exclusive buffer lock (and it must also be WAL-logged).</p>
</blockquote>

<p>单独 OR 其中一个 bit 是 Rule 4 的 best-effort 写; 两个一起设 (= freeze) 是 critical update, 必须持 exclusive buffer lock + WAL-logged. Freeze 改变的是 tuple 的权威可见性状态, 丢不得, 也不能让 reader 读到中间态.</p>

<p><strong>Rule 4 为什么必须存在 — 性能动机</strong></p>

<p>如果没有 Rule 4, 每次 SELECT 遇到一个 hint bit 还没设上的 tuple, 都要把 shared lock 升级到 exclusive lock 才能设 hint bit. 这对 OLTP 灾难性:</p>

<ul>
  <li>第一次 SELECT 一个新插入的 page, 全部 tuple 的 hint bit 都没设, 全部需要 exclusive lock</li>
  <li>多个 SELECT 并发, 互斥, 串行化</li>
  <li>SELECT 看起来是只读操作, 突然变成需要 exclusive lock 的写操作</li>
</ul>

<p>Rule 4 让 SELECT 在逻辑上仍然是只读 (从锁的语义看 shared lock 就够), 顺手做 hint bit 写入是个 best-effort 的副作用. 实际跑 benchmark 时大家观察到的 “首次 SELECT 比后续 SELECT 慢” 现象就是 hint bit 在第一次访问时被设上.</p>

<h4 id="rule-5-cleanup-lock--物理整理需要-refcount--1">Rule 5: cleanup lock — 物理整理需要 refcount = 1</h4>

<blockquote>
  <p>To physically remove a tuple or compact free space on a page, one must hold a pin and an exclusive lock, and observe while holding the exclusive lock that the buffer’s shared reference count is one (ie, no other backend holds a pin). If these conditions are met then no other backend can perform a page scan until the exclusive lock is dropped, and no other backend can be holding a reference to an existing tuple that it might expect to examine again.</p>
</blockquote>

<p>这是 cleanup lock 的语义, 也是 Rule 2 的兑现机制.</p>

<p>物理整理 = HOT prune / vacuum 删 line pointer / PageRepairFragmentation 搬 tuple. 这些操作会改变 line pointer 数量或 tuple 物理偏移, 任何持有这些”过时”指针的 backend 会得出错误结论. 所以必须:</p>

<ol>
  <li>持 exclusive content lock (排除并发字节级访问)</li>
  <li>观察 refcount = 1 (确认没有 backend 持有 Pin)</li>
</ol>

<p><strong>LockBufferForCleanup 的实现</strong></p>

<blockquote>
  <p>Obtaining the lock needed under rule #5 is done by the bufmgr routines LockBufferForCleanup() or ConditionalLockBufferForCleanup(). They first get an exclusive lock and then check to see if the shared pin count is currently 1. If not, ConditionalLockBufferForCleanup() releases the exclusive lock and then returns false, while LockBufferForCleanup() releases the exclusive lock (but not the caller’s pin) and waits until signaled by another backend, whereupon it tries again. The signal will occur when UnpinBuffer decrements the shared pin count to 1. As indicated above, this operation might have to wait a good while before it acquires the lock, but that shouldn’t matter much for concurrent VACUUM.</p>
</blockquote>

<p>实现上的关键序列是这样:</p>

<pre><code class="language-c">for (;;) {
    LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);   /* 1. 拿 X content lock */

    refcount = ...;
    if (refcount == 1)
        return;                                  /* 2a. 成功, 拿到 cleanup lock */

    /* 2b. 失败: 别人持 pin. 必须释放 X lock */
    LockBuffer(buffer, BUFFER_LOCK_UNLOCK);

    /* 注意: 这里释放的是 content lock, 不释放 caller 自己的 pin */

    /* 3. 把自己挂到 BM_PIN_COUNT_WAITER, 等别人 unpin 时唤醒 */
    ProcSleep(...);

    /* 4. 醒了重试 */
}
</code></pre>

<p>几个关键细节:</p>

<ol>
  <li>先拿 X content lock, 再查 refcount, 不是反过来. 这个顺序很重要 — 如果反过来 “先查 refcount 再拿 X lock”, 中间会有窗口让别的 backend pin 进来, 查到 refcount = 1 但真正拿到 X lock 时已经 refcount &gt; 1.</li>
  <li>失败时只释放 X content lock, 不释放 caller 的 pin. 这意味着 VACUUM 自己也持着 pin 在等. 这是设计上的考虑 — VACUUM 必须先 pin 这个 page 才能锁定 “我要清理的就是这个 page”, 失败重试期间放 pin 没意义.</li>
  <li>唤醒机制走 UnpinBuffer. 别的 backend UnpinBuffer 把 refcount 减到 1 时, 检查 BM_PIN_COUNT_WAITER flag, 给挂在上面的 waiter 发信号. 整个机制不需要 polling, 是 event-driven 的.</li>
  <li>VACUUM 等 cleanup lock 期间, 自己处于 “pin 不持 content lock” 状态. 这其实让 vacuum 不会阻塞别的 reader 拿 share lock 读 page — 别人照样读, 只是物理整理推迟. 这是协议设计很温和的一点.</li>
</ol>

<p><strong>single-waiter 限制</strong></p>

<blockquote>
  <p>The current implementation only supports a single waiter for pin-count-1 on any particular shared buffer. This is enough for VACUUM’s use, since we don’t allow multiple VACUUMs concurrently on a single relation anyway. Anyone wishing to obtain a cleanup lock outside of recovery or a VACUUM must use the conditional variant of the function.</p>
</blockquote>

<p>BM_PIN_COUNT_WAITER 这个 flag 是 BufferDesc.state 里的一个 bit, 在 buffer header 上只能挂一个 waiter 的 backend pgprocno. 这就是 single-waiter 限制的物理原因 — 这一个 bit 决定的, 不是别的设计.</p>

<p>这个限制带来两条约束:</p>

<ol>
  <li>同一个 relation 上不允许有多个并发 VACUUM. PG 通过 relation 级别的 lock (ShareUpdateExclusiveLock) 来保证这一点, autovacuum / 手动 VACUUM 都拿这把 relation lock, 互斥. 这是规避 cleanup lock single-waiter 限制的上层保护.</li>
  <li>Recovery 和 VACUUM 之外的 cleanup lock 必须用 conditional 版本. 比如 HOT prune 在 heap_page_prune_opt 路径上用的就是 ConditionalLockBufferForCleanup, 拿不到就跳过这个 page, 不阻塞前台查询. 这是工程上很务实的妥协 — HOT prune 是机会主义的, 不是必须做.</li>
</ol>

<p>只有 LockBufferForCleanup 这个阻塞版本会用到 single-waiter slot, conditional 版本根本不挂 waiter 直接返回 false. 所以 single-waiter 真正限制的是 “谁能阻塞等待”, 不是 “谁能尝试 cleanup”.</p>

<p>顺便提一下, InnoDB 也有 pin — 就是 io_fix, buf_fix_count, 也大量用裸指针 (rec_t 直接指向 frame). 但是并没有约束在持有 buf_fix_count 期间不让 record/tuple 位置发生偏移这个约束</p>

<h4 id="总结">总结</h4>

<p>PG 这 5 条 buffer access rules 是它整个并发协议的基本要求. vacuum 进度被卡, autovacuum 调度逻辑, hint bit 引起的 dirty page 写放大, FPW 跟 hint bit 的交互, BTree scan 的 kill_prior_tuple 等等, 都是在这个设计下出现的结果.</p>

<p>核心是理解两件事:</p>

<ol>
  <li>Pin 和 content lock 是独立的两个原语, 可以脱钩, “pin 不持 lock” 是 OLTP 主流状态而非边缘情况</li>
  <li>Rule 2 把 “pin 期间 tuple 位置稳定” 作为契约暴露给上层, Rule 5 通过 cleanup lock 兑现这个契约, 让 executor 可以用裸指针访问 buffer 内字节</li>
</ol>]]></content><author><name>baotiao</name></author><category term="Other" /><summary type="html"><![CDATA[src/backend/storage/buffer/README 是 PG 社区维护 buffer manager 的官方设计文档. 它在开头列了 5 条 buffer access rules, 提 patch / review 时直接引用. 这 5 条规则合起来定义了 PG 的 Pin 协议, 也是 PG 和 InnoDB buffer manager 设计上真正分叉的地方.]]></summary></entry><entry><title type="html">MySQL/PostgreSQL Slot-based Buffer Manager Pin/buf_block_fix operator</title><link href="http://baotiao.github.io/2026/05/07/slot-based-buffer-manager.html" rel="alternate" type="text/html" title="MySQL/PostgreSQL Slot-based Buffer Manager Pin/buf_block_fix operator" /><published>2026-05-07T00:00:00+00:00</published><updated>2026-05-07T00:00:00+00:00</updated><id>http://baotiao.github.io/2026/05/07/slot-based-buffer-manager</id><content type="html" xml:base="http://baotiao.github.io/2026/05/07/slot-based-buffer-manager.html"><![CDATA[<p>在 MySQL/PostgreSQL Buffer Pool 里面有一个 Pin 操作 — PostgreSQL 叫 Pin, MySQL InnoDB 叫 buf_block_fix / io_fix. 这些操作本质上都是把一个 page “pin” buffer pool 的某个位置上.</p>

<p>为什么在其他系统里很少见到这种代码? 答案是 PG 和 InnoDB 的 buffer pool 都用了同一种架构 — Slot-based Buffer Manager. 这种架构直接决定了 Pin 这个操作必须存在.</p>

<h4 id="slot-based-buffer-manager-结构">Slot-based Buffer Manager 结构</h4>

<p>启动时, buffer pool 被切成 N 个固定大小的 slot (InnoDB 是 16KB, PG 是 8KB). slot 总数 N 在启动后不再变化.</p>

<p>数据结构上分三层:</p>

<ul>
  <li>Slot / 描述符: 启动时静态分配, 地址永不变 (buf_block_t / BufferDesc)</li>
  <li>Frame / 页面内存: 启动时静态分配, 地址永不变 (buf_block_t-&gt;frame / BufferBlocks[i*BLCKSZ])</li>
  <li>Page Identity: 当前 slot 装的是哪个磁盘 page ((space_id, page_no) / (rel, fork, blkno)), 这个会变</li>
</ul>

<pre><code class="language-cpp">[ slot / 描述符 ]      &lt;-- 启动时静态分配, 地址永不变
       │
       │ 永久指向
       ▼
[ frame / 页面内存 ]    &lt;-- 启动时静态分配, 地址永不变
       │
       │ 当前装着哪个逻辑 page
       ▼
[ page identity ]       &lt;-- (rel, fork, blkno) / (space_id, page_no), 流动的
</code></pre>

<p>slot 和 frame 之间是启动时永久绑定的, 终身不变. 真正会变的只有 page identity — evict 的本质就是把 slot 上挂的 page identity 改成另一个, 然后把磁盘上新 page 的内容读到这个 slot 对应的 frame 内存里.</p>

<p>Pin 锁定的就是 slot ↔ 当前装的 page identity 这个映射. 在我持 pin 期间, 这个 slot 装的还得是同一个 page, 不能被换走.</p>

<h4 id="为什么要-pin-住-page">为什么要 Pin 住 page</h4>

<p><strong>1. 固定内存物理位置</strong></p>

<p>page 被 pin 住, 它所在的 slot 位置就固定了. slot 固定 → 对应的 frame 内存地址固定 → page 内任何字节的物理地址都固定.</p>

<p><strong>2. 支持裸指针操作</strong></p>

<p>PG 和 MySQL 的代码里到处都是直接指向 page 内部地址的裸指针:</p>

<ul>
  <li>PG 的 HeapTuple.t_data — 指向 buffer 内某条 tuple 的 header</li>
  <li>InnoDB 的 rec_t *rec — 指向 page 内某条 record 的偏移</li>
  <li>跨函数传递的 byte * / Page 字节指针</li>
</ul>

<p>只要 page 被 pin 住, 这些裸指针就一直有效, 上层可以反复 deref. 这是 OLTP 热路径上每行数据访问 0 次 hash lookup, 0 次 IO 的根本原因.</p>

<p><strong>3. 防止被淘汰或置换</strong></p>

<p>pin 住以后, 这个 page 不会被 LRU 淘汰 (InnoDB), 也不会被 clock-sweep 选作 victim (PG). buffer replacement 算法在挑牺牲者时直接跳过持 pin 的 slot.</p>

<h4 id="如果不-pin-会怎样">如果不 Pin 会怎样</h4>

<p>假设上层手里有一个指向 page 内某条 tuple 的裸指针, 但没有 pin 住这个 page. 这时 buffer replacement 把这个 slot 选成牺牲者, evict 当前 page, 换上别的 page.</p>

<p>即便这个 page 稍后又从磁盘读回 buffer pool, 分配到的可能是另一个 slot, frame 起始地址完全不同. 上层手里的裸指针指向的还是原来那个 slot 的 frame, 但那段内存里已经是别的 page 的字节了. 之前存储的所有裸指针都失效, 直接崩.</p>

<p>所以 Pin 的最大意义就是确保 page 所在的内存物理位置不变. 没有 pin, slot-based buffer manager 就不能给上层暴露裸指针 API, 也就失去了它最大的性能优势.</p>

<h4 id="三层保护机制">三层保护机制</h4>

<p>Pin 不是 buffer manager 唯一的同步原语. 完整体系是三层正交保护, 每层各管一块:</p>

<table>
  <thead>
    <tr>
      <th>保护对象</th>
      <th>InnoDB</th>
      <th>PostgreSQL</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>slot ↔ page identity 映射</td>
      <td>buf_fix_count</td>
      <td>BufferDesc.refcount</td>
    </tr>
    <tr>
      <td>frame 内部字节内容</td>
      <td>block-&gt;lock (rw_lock)</td>
      <td>content lock (LWLock)</td>
    </tr>
    <tr>
      <td>描述符元数据本身</td>
      <td>buf_block_t::mutex</td>
      <td>buffer header spinlock</td>
    </tr>
  </tbody>
</table>

<p>每一层粒度和持有时间都不一样:</p>

<ul>
  <li>Pin 持有时间最长, 跨整个 mtr / query 都行. 原子计数器, 极轻量.</li>
  <li>Frame latch (block-&gt;lock / content lock) 持有时间中等, 覆盖一次 page 修改的 critical section.</li>
  <li>Header lock 持有时间最短, 仅保护描述符元数据自身的瞬时一致性.</li>
</ul>

<p>三个原语相互独立, 不能互相替代. Pin 保护 slot 占用, latch 保护字节内容, header lock 保护描述符自身. 任意一层失守, 上层都会出问题.</p>

<h4 id="postgresql-pin-的额外语义">PostgreSQL pin 的额外语义</h4>

<p>InnoDB 和 PostgreSQL 的 Pin 在 “锁定 slot ↔ page identity 映射” 这个核心语义上是一致的, 但 PG 还多做了一件事: 持 Pin 期间, page 内 tuple 的物理位置也不能被搬动. InnoDB 没有这个保证.</p>

<p>下一篇专门讲这个差异, 以及 PG 的 buffer/README 里的 5 条 access rules 是怎么把这个额外契约表达出来的.</p>]]></content><author><name>baotiao</name></author><category term="Other" /><summary type="html"><![CDATA[在 MySQL/PostgreSQL Buffer Pool 里面有一个 Pin 操作 — PostgreSQL 叫 Pin, MySQL InnoDB 叫 buf_block_fix / io_fix. 这些操作本质上都是把一个 page “pin” buffer pool 的某个位置上.]]></summary></entry><entry><title type="html">C++ StringView 优化字符串比较</title><link href="http://baotiao.github.io/2026/04/24/cpp-stringview.html" rel="alternate" type="text/html" title="C++ StringView 优化字符串比较" /><published>2026-04-24T00:00:00+00:00</published><updated>2026-04-24T00:00:00+00:00</updated><id>http://baotiao.github.io/2026/04/24/cpp-stringview</id><content type="html" xml:base="http://baotiao.github.io/2026/04/24/cpp-stringview.html"><![CDATA[<p>DuckDB / Velox / Umbra 里面常见的字符串表示方式. 和传统的 SimpleStr <code>(ptr, len)</code> 相比, 都是 16 字节, 但是 layout 不同.</p>

<pre><code>SimpleStr:  [ ptr (8B) ][ len (4B) ][ pad (4B) ]

StringView:
  短字符串 (len ≤ 12): [ len (4B) ][ inline_data (12B)        ]
  长字符串 (len  &gt; 12): [ len (4B) ][ prefix (4B) ][ ptr (8B) ]
</code></pre>

<p>两个优化点:</p>

<ul>
  <li>短字符串直接 inline 存在 struct 里, 比较的时候完全不需要 deref ptr.</li>
  <li>长字符串把前 4 个字节的 prefix 存在 struct 里, 大部分不匹配的情况在 prefix check 阶段就拒掉了, 不需要访问 heap.</li>
</ul>

<p><strong>随机访问场景下的优势</strong></p>

<p>在 column storage 里面, 字符串数据通常散布在 heap file 的各处. 字符串数据散布在 256MB buffer 里 (远超 L3 cache), 每次 deref 都是 DRAM miss (~100ns). 这个时候 inline 和 prefix 的价值就出来了.</p>

<p>N=1M 条字符串, 数据随机散布在 256MB buffer 里:</p>

<pre><code>                     SimpleStr       StringView    Speedup
短字符串 (len=8)     14.74 ns/row    2.75 ns/row   5.36x
长字符串 (len=25)    15.88 ns/row    2.47 ns/row   6.42x
</code></pre>

<p>SimpleStr 散乱场景下每行 ~15ns 基本就是一次 DRAM round-trip. StringView 短字符串不访问 heap, 长字符串只有 ~5% 的行需要 deref (prefix 通过以后才去访问), 所以平均下来接近顺序访问的速度.</p>

<p><strong>C++ union 实现</strong></p>

<p>两个 member 都把 length 放在 offset 0, 所以读 <code>non_inline.length</code> 对两条路径都有效.</p>

<pre><code class="language-cpp">struct StringView {
    union {
        struct { uint32_t length; char prefix[4]; const char* ptr; } non_inline;
        struct { uint32_t length; char data[12];                  } inlined;
    };
};

inline StringView make_view(const char* data, uint32_t len) {
    StringView v;
    if (len &lt;= 12) {
        v.inlined.length = len;
        std::memset(v.inlined.data, 0, 12);
        std::memcpy(v.inlined.data, data, len);
    } else {
        v.non_inline.length = len;
        std::memcpy(v.non_inline.prefix, data, 4);
        v.non_inline.ptr = data;
    }
    return v;
}
</code></pre>

<p>Equality scan kernel:</p>

<pre><code class="language-cpp">if (strs[i].non_inline.length != tlen) continue;
if (tlen &lt;= 12) {
    if (memcmp(strs[i].inlined.data, target.inlined.data, tlen) == 0) matches++;
} else {
    uint32_t a, b;
    memcpy(&amp;a, strs[i].non_inline.prefix, 4);
    memcpy(&amp;b, target.non_inline.prefix,  4);
    if (a != b) continue;
    if (memcmp(strs[i].non_inline.ptr, target.non_inline.ptr, tlen) == 0) matches++;
}
</code></pre>

<p><strong>顺序访问场景下不一定有优势</strong></p>

<p>heap 是连续分配的时候, hardware prefetcher 能预测下一次 deref 的目标, 把 cache miss 的代价掩盖掉了. 顺序场景下 SimpleStr 反而比 StringView 略快一点.</p>

<p>N=10M 条字符串, 数据连续分配:</p>

<pre><code>                     SimpleStr       StringView    Speedup
短字符串 (len=8)      3.51 ns/row     4.08 ns/row   0.86x
长字符串 (len=25)     3.14 ns/row     3.39 ns/row   0.93x
混合 50/50            5.56 ns/row     4.84 ns/row   1.22x
</code></pre>

<p>但在大多数 column storage 里面, string column 的数据散布在 heap file 里, 还是以随机分布的 column scan 居多, 所以 StringView 的优势是实际成立的.</p>

<p><strong>一个反直觉的现象</strong></p>

<p>仔细看两组数字会发现一件奇怪的事: StringView 在随机访问场景下 (2.75 ns/row) 比顺序场景下 (4.08 ns/row) 还要快. 照理说随机访问应该更慢才对.</p>

<p>原因是这两组 benchmark 用的 N 不同. 顺序测试用了 N=10M, struct 数组本身就有 10M × 16B = 160MB, 超过 L3 cache, 必须从 DRAM streaming 读. 随机测试为了让运行时间合理, 用的是 N=1M, struct 数组只有 16MB, warmup 跑完之后就常驻 L3 了.</p>

<p>对短字符串来说, StringView 完全不碰 heap, 所以”散乱”这件事对它毫无影响. 随机测试里 StringView 实际上在做的是: 顺序扫描一个 16MB 的热 L3 数组, 每行 in-struct 比较即结束. 这比顺序测试里 streaming 160MB DRAM 要快.</p>

<p><strong>编译</strong></p>

<pre><code>g++ -O3 -std=c++17 -march=native t.cc -o demo
</code></pre>

<p><code>-march=native</code> 让编译器为当前 CPU 启用全部指令集扩展 (AVX2, SSE4.2 等). memcmp 会被向量化. 生成的二进制不可移植.</p>

<p>完整代码见 <a href="https://gist.github.com/baotiao/76c63ff8cc68ea6881ec423617cfdce0">Gist</a>.</p>]]></content><author><name>baotiao</name></author><category term="Other" /><summary type="html"><![CDATA[DuckDB / Velox / Umbra 里面常见的字符串表示方式. 和传统的 SimpleStr (ptr, len) 相比, 都是 16 字节, 但是 layout 不同.]]></summary></entry><entry><title type="html">从 PostgreSQL fsync EIO 失败处理说起</title><link href="http://baotiao.github.io/2026/04/06/postgresql-fsync.html" rel="alternate" type="text/html" title="从 PostgreSQL fsync EIO 失败处理说起" /><published>2026-04-06T00:00:00+00:00</published><updated>2026-04-06T00:00:00+00:00</updated><id>http://baotiao.github.io/2026/04/06/postgresql-fsync</id><content type="html" xml:base="http://baotiao.github.io/2026/04/06/postgresql-fsync.html"><![CDATA[<p>2018 年, PostgreSQL 社区发现了一个存在了 20 年的严重问题: 当 <code>fsync()</code> 失败时, PostgreSQL 的处理方式可能导致<strong>静默数据丢失</strong>. 这个被称为 “fsyncgate” 的事件, 不仅揭示了 PostgreSQL 自身的架构缺陷, 更暴露了 Linux 内核, 文件系统与数据库之间在 I/O 错误处理上的深层矛盾.</p>

<p>在云原生时代, 这个问题的影响被显著放大 – 因为云存储上 I/O 错误的发生频率远高于本地存储. 本文将完整梳理这一问题的发现, 讨论, 解决方案, 以及它在云原生环境下带来的新挑战.</p>

<h4 id="问题的发现">问题的发现</h4>

<h4 id="craig-ringer-的报告">Craig Ringer 的报告</h4>

<p>2018 年 3 月底, Craig Ringer 在 pgsql-hackers 邮件列表中报告了一个用户遭遇的数据损坏案例 [1]. 问题的核心在于: PostgreSQL 使用 Buffered I/O, 在写入数据后调用 <code>fsync()</code> 来确保数据落盘. 当 <code>fsync()</code> 失败时, PostgreSQL 的做法是重试 <code>fsync()</code> – 然而第二次 <code>fsync()</code> 返回了成功, 但数据实际上并没有写入磁盘.</p>

<p>为什么会这样? 因为 Linux 内核在 <code>fsync()</code> 失败后, 会将相关的 dirty page 标记为 <strong>clean</strong> – 即使数据并没有成功写入磁盘. 当 PostgreSQL 重试 <code>fsync()</code> 时, 内核发现没有 dirty page 需要刷盘, 直接返回成功. PostgreSQL 以为数据已经安全落盘, 继续截断了 WAL – 数据就这样丢了.</p>

<p>Craig Ringer 的结论很直接: <strong>Pg should PANIC on fsync() EIO return.</strong></p>

<h4 id="postgresql-社区的反应">PostgreSQL 社区的反应</h4>

<p>PostgreSQL 开发者们对此非常愤怒. Tom Lane 称之为 “kernel brain damage”, Robert Haas 认为这种行为 “100% unreasonable”. 他们最初认为内核的正确行为应该是: <code>fsync()</code> 失败后保持 page 的 dirty 状态, 以便后续重试.</p>

<p>但随着讨论深入, 事情变得复杂了.</p>

<h4 id="为什么内核要把失败的-page-标记为-clean">为什么内核要把失败的 page 标记为 clean?</h4>

<h4 id="usb-拔出场景">USB 拔出场景</h4>

<p>Ted Ts’o (ext4 maintainer) 给出了内核行为背后的主要理由: 触发 <code>fsync()</code> EIO 最常见的场景是用户拔掉 USB 盘.</p>

<p>当用户往 USB 盘上拷贝大文件时突然拔掉设备, 内核 page cache 中可能有 GB 级的 dirty page 等待写入一个已经不存在的设备. 如果保持这些 page 为 dirty, 它们永远无法被写出去, 也无法被内存回收器释放, 最终可能导致系统 OOM.</p>

<h4 id="内存管理的架构约束">内存管理的架构约束</h4>

<p>Neil Brown 解释了更底层的问题: Linux 的内存管理建立在一个核心假设之上 – dirty page 可以通过 writeback 变成 clean page, clean page 可以被回收释放. 如果允许 “永远 dirty 但永远写不出去” 的 page 存在, 整个内存管理子系统的假设就被打破了, 可能导致死锁.</p>

<h4 id="freebsd-的做法">FreeBSD 的做法</h4>

<p>有趣的是, FreeBSD 确实做了 Linux 没做的事情: <code>fsync()</code> 失败后保持 page 为 dirty, 后续 <code>fsync()</code> 会重新尝试写入. 这个行为从 1999 年就存在了, 证明 “保持 dirty” 在技术上是可行的. 但 FreeBSD 也做了妥协 – 如果设备彻底消失, 较新版本会最终放弃这些 page.</p>

<h4 id="本质是需求冲突">本质是需求冲突</h4>

<p>内核开发者面对的是所有 Linux 用户: 桌面, 手机, IoT, 服务器. 对于 99% 的场景, USB 拔出后的内存回收比数据库的 <code>fsync()</code> 可靠性重要得多. 数据库开发者面对的是数据持久化的最严格要求. 两个需求在 Buffered I/O 语义下是根本矛盾的. Linux 选择了优先照顾大多数场景, 把数据库推向 Direct I/O.</p>

<h4 id="postgresql-的解决方案">PostgreSQL 的解决方案</h4>

<h4 id="panic-on-fsync-failure">PANIC on fsync failure</h4>

<p>2018 年 11 月, PostgreSQL 合入了 commit <code>9ccdd7f6</code>: “PANIC on fsync() failure.” [2]. 作者是 Craig Ringer, Thomas Munro 做了调整. 核心逻辑如 commit message 所述:</p>

<blockquote>
  <p>On some operating systems, it doesn’t make sense to retry fsync(), because dirty data cached by the kernel may have been dropped on write-back failure. In that case the only remaining copy of the data is in the WAL. A subsequent fsync() could appear to succeed, but not have flushed the data. Therefore, violently prevent any future checkpoint attempts by panicking on the first fsync() failure.</p>
</blockquote>

<p>这个改动被 backport 到了所有受支持的版本 (PG 11, 10, 9.6, 9.5, 9.4), 对应的 GUC 参数是 <code>data_sync_retry</code>, 默认为 <code>off</code> (即 fsync 失败直接 PANIC).</p>

<h4 id="panic-策略的代价">PANIC 策略的代价</h4>

<p>这个方案在正确性上是安全的 – 避免了静默数据损坏. 但代价是可用性下降: 一次 I/O 错误就导致整个数据库实例 crash, 需要进行 WAL recovery, 可能耗时数分钟到数十分钟.</p>

<h4 id="wal-本身也走-buffered-io">WAL 本身也走 Buffered I/O</h4>

<p>值得注意的是, PostgreSQL 的 WAL 在默认配置下也是通过 Buffered I/O 写入的 (<code>wal_sync_method</code> 默认为 <code>fdatasync</code>). PANIC 后依赖 WAL replay 恢复数据, 但 WAL 本身的写入也经过了 page cache. 虽然 PostgreSQL 对 WAL 的 fsync 失败处理更早就做了 PANIC, 但仍存在 “后台 writeback 失败 → page 被标记为 clean → fdatasync 返回成功” 的边界窗口. 4.13+ 内核的 errseq_t 机制缓解了这个问题, 但无法根治.</p>

<h4 id="direct-io-尚未落地的根本解决方案">Direct I/O: 尚未落地的根本解决方案</h4>

<p>内核开发者 (Dave Chinner, Ted Ts’o 等) 一致认为, 正确的长期方案是 PostgreSQL 切换到 Direct I/O, 绕过 page cache, 让数据库自己完全控制 I/O 和错误处理. PG 开发者也承认这是正确方向, 但 Andres Freund 称之为 “a metric ton of work” – 至今仍未落地.</p>

<h4 id="不仅仅是-postgresql-的问题">不仅仅是 PostgreSQL 的问题</h4>

<h4 id="wisconsin-大学的系统性研究">Wisconsin 大学的系统性研究</h4>

<p>Wisconsin 大学 Arpaci-Dusseau 组在 USENIX ATC 2020 发表了论文 “Can Applications Recover from fsync Failures?” [3], 系统性测试了五个广泛使用的数据管理应用在 fsync 失败时的行为.</p>

<p><strong>LevelDB</strong>: LevelDB 使用 CRC 校验和检测损坏的 log entry. 但问题在于, fsync 失败后数据留在 page cache 中, 当前进程的读操作能正常返回新值. 只有当 page 被 evict 或应用重启后, CRC 才检测到损坏, LevelDB 拒绝这条 log entry, 出现 KeyNotFound 或 OldVersion 错误 – 一个 “薛定谔” 状态.</p>

<p>**SQLite (Rollback Journal 模式) **: SQLite 往 rollback journal 写原始页面备份时如果 fsync 失败, journal 中的数据实际没有落盘. 后续如果需要回滚事务, SQLite 会从 journal 中读取数据 – 如果 page 已被 evict, 读到的是垃圾数据, SQLite 用这些垃圾覆盖了数据库中原本正确的页面, 造成数据库损坏.</p>

<p><strong>Redis</strong>: 甚至不检查 <code>fsync()</code> 的返回值.</p>

<p>论文结论: 尽管这些应用使用了多种错误处理策略 (CRC, journal header 顺序写入等), 但没有一个是充分的. 只要使用 Buffered I/O, fsync 错误不被正确处理, 数据持久性就无法保证.</p>

<h4 id="为什么这些数据库没有在-fsync-失败后-crash">为什么这些数据库没有在 fsync 失败后 crash?</h4>

<p>原因是多方面的:</p>

<ol>
  <li><strong>认知盲区</strong>: 2018 年之前, 几乎所有数据库开发者都不知道内核会在 fsync 失败后丢弃 dirty page.</li>
  <li><strong>本地存储极少触发</strong>: EIO 在本地 SSD/HDD 上几乎只在物理损坏时才出现, 一辈子可能遇不到.</li>
  <li><strong>crash 后未必能恢复</strong>: LevelDB 的 log 和 SQLite 的 journal 也走 Buffered I/O, crash 后的 recovery source 本身可能就是损坏的.</li>
  <li><strong>产品约束</strong>: SQLite 和 LevelDB 是嵌入式数据库, 因一次瞬态 I/O 错误就把宿主应用杀掉, 在移动端和桌面端不可接受.</li>
</ol>

<h4 id="postgresql-的其他类似问题">PostgreSQL 的其他类似问题</h4>

<p>fsyncgate 并非 PostgreSQL 第一次因为对 OS 层行为做了过多假设而踩坑:</p>

<h4 id="torn-page-问题">Torn Page 问题</h4>

<p>PostgreSQL 使用 8KB 页, 但 Linux 文件系统通常用 4KB 页. 写一个 8KB 页时如果系统 crash, 可能只有 4KB 被写入, 页面混合了新旧数据. PostgreSQL 通过 Full Page Writes (FPW) 机制来解决这个问题 – 在 checkpoint 后每个页面第一次被修改时, 把完整的 8KB 页面写入 WAL.</p>

<p>我在之前的工作中用 Claude Code 在 PostgreSQL 中实现了 MySQL 风格的 Doublewrite Buffer (DWB), benchmarks 显示 DWB 的性能是 FPW 的约 2.3 倍 (write_only 128 并发场景) [4]. DWB 的优势在于它在后台路径执行, 不影响前台 SQL latency, 并且不与 Checkpoint 频率冲突.</p>

<h4 id="lvm-write-barrier-问题">LVM Write Barrier 问题</h4>

<p>Linux 2.6.33 之前, device-mapper (LVM 的基础) 对 write barrier 的支持不完整. 文件系统发出的 write barrier 被 device-mapper 层静默吞掉, 底层磁盘缓存中的数据顺序不确定. 断电后可能丢失最近写入的文件系统元数据和 journal 数据 (每块 SATA 盘可能丢失 32MB), 导致大量文件系统损坏和数据丢失 [5].</p>

<h4 id="glibc-locale-变更导致索引损坏">glibc locale 变更导致索引损坏</h4>

<p>通过 pg_basebackup 或 streaming replication 从一个 OS 版本迁移到另一个版本时 (如 CentOS 7 → CentOS 8), 如果底层 glibc 的 locale collation 实现发生变化, 会导致 B-tree 索引静默损坏 [6].</p>

<p>这些问题的共同根源是: PostgreSQL 的 Buffered I/O 架构对 OS 层行为做了过多乐观假设.</p>

<h4 id="云原生时代-问题被显著放大">云原生时代: 问题被显著放大</h4>

<h4 id="eio-的语义变化">EIO 的语义变化</h4>

<p>在本地存储时代, <code>fsync()</code> 返回 EIO 几乎只在磁盘物理损坏时才会发生 – 这是一个极其罕见的永久性故障. 本地 SSD 的 I/O 路径很短: 应用 → 内核 page cache → 文件系统 → block 层 → 磁盘控制器 → 物理介质. 中间环节很少, 能出错的基本就是物理介质本身.</p>

<p>但在云存储环境下, I/O 路径变成了: 应用 → 内核 page cache → 文件系统 → block 层 → virtio 驱动 → 宿主机内核 → 网络栈 → 交换机 → 存储节点 → 分布式存储引擎 → 多副本复制 → 物理介质. 这条路径上每一个环节都可能产生瞬态错误: 网络超时, 交换机切换, 存储节点 GC, 虚拟机热迁移等.</p>

<p><strong>关键区别在于瞬态性</strong>: 本地存储的 EIO 几乎总是永久性的; 云存储的 EIO 大量是瞬态的 – 100ms 到几秒后可能就会自动恢复.</p>

<h4 id="planetscale-的实证数据">PlanetScale 的实证数据</h4>

<p>PlanetScale 在 2025 年 3 月发表的 “The Real Failure Rate of EBS” [7] 提供了大规模生产数据的实证. AWS 官方文档承认 gp2/gp3 EBS 卷在一年中有 1% 的时间性能低于预期 – 每天约 14 分钟, 每年约 86 小时. 这个降级率远超单块本地磁盘或 SSD.</p>

<p>更关键的是规模效应: 对于一个 256 shard, 每个 shard 一主两从共 768 个 gp3 EBS 卷的大型数据库, 在任何给定时间有至少一个节点遇到生产级影响事件的概率是 99.65%. 即使使用价格 4-10 倍的 io2 卷, 一年中大约三分之一的时间仍然会处于某种故障状态.</p>

<p>PlanetScale 最终的选择是构建 PlanetScale Metal, 用 shared-nothing 架构配合本地存储来替代 EBS.</p>

<h4 id="来自中国云的实践反馈">来自中国云的实践反馈</h4>

<p>Hacker News 上也有用户分享了中国云环境的经验: 在阿里云, 腾讯云, 华为云上, 每块云盘每个月至少会经历一次致命故障或断连, 最终不得不放弃在云盘上直接运行数据库负载 [8].</p>

<h4 id="对-postgresql-panic-策略的影响">对 PostgreSQL PANIC 策略的影响</h4>

<p>结合 PostgreSQL 的 fsync-failure-PANIC 行为和云存储天然更高的 I/O 错误率, 在云上运行 PostgreSQL 面临显著的可用性风险: 数据库可能因为一次几百毫秒后就自动恢复的网络抖动而 PANIC 整个实例, 每次 PANIC 后的 WAL recovery 可能需要数分钟到数十分钟 – 这对于一个本来只持续几百毫秒的瞬态故障来说是完全不对等的代价.</p>

<h4 id="cloudjump-云存储与数据库的系统性适配">CloudJump: 云存储与数据库的系统性适配</h4>

<p>在我们发表于 VLDB 2022 的论文 CloudJump [9] 中, 我们系统性地分析了云存储与本地存储的特性差异对数据库设计的影响, 并提出了七条优化准则. 其中与本文讨论直接相关的几个点:</p>

<p><strong>I/O 延迟与隔离性问题</strong>: 云存储的 I/O 延迟显著高于本地 SSD, 且不同 I/O 请求之间的隔离性较低. CloudJump 提出了多 I/O 任务队列和优先级调度机制, 为 WAL 写入保留专用的 Private 队列, 确保关键 I/O 路径的性能.</p>

<p><strong>WAL 写入优化</strong>: 针对云存储高延迟的特点, CloudJump 提出了 Redo 日志分片和 I/O 任务并行打散 – 将 WAL 按 page 分片写入不同文件, 利用分布式存储的聚合带宽. 这些优化使得 WAL 写入路径对云存储的瞬态延迟抖动有更好的容忍度.</p>

<p><strong>I/O 格式对齐</strong>: 云存储有更大的 block size (4-128KB), 传统的 I/O 对齐策略不适合. CloudJump 提出在数据库内核层面对 WAL I/O 和 Data I/O 进行对齐, 减少 read-on-write 问题.</p>

<p>CloudJump 的优化框架在 PolarDB 和 RocksDB 上均获得了显著的性能提升, 验证了针对云存储特性进行数据库层面系统性适配的必要性和有效性.</p>

<p>然而, CloudJump 主要关注的是性能优化层面. fsyncgate 揭示的问题则处于更深的正确性层面: <strong>云存储的瞬态 EIO 需要数据库有完全不同的错误处理语义</strong>. 这是 CloudJump 框架的一个自然延伸方向.</p>

<h4 id="面向云原生的-fsync-错误处理">面向云原生的 fsync 错误处理</h4>

<h5 id="核心洞察">核心洞察</h5>

<p><strong>在云原生环境中, 大部分 EIO 是瞬态的, 100ms 到几秒后就会恢复.</strong> 这改变了 fsync 失败处理的整个决策框架.</p>

<p>PostgreSQL 当前的 PANIC 策略本质上是一个悲观策略: 把所有 EIO 都当作最坏情况处理. 这在正确性上是安全的, 但在云环境下代价过高.</p>

<h5 id="改进思路-区分-wal-和数据文件">改进思路: 区分 WAL 和数据文件</h5>

<p>要在 PANIC 和忽略之间找一个中间地带, 需要分开讨论 WAL 文件和数据文件两种情况 – 它们面临的约束完全不同.</p>

<h5 id="wal-文件的-fsync-失败">WAL 文件的 fsync 失败</h5>

<p>WAL 文件的 fsync 失败后, PANIC 是正确的, 没有优雅重试的空间. 原因很明确: WAL 在默认配置下走 Buffered I/O (<code>wal_sync_method=fdatasync</code>). fsync 失败后, 内核将这些 WAL page 标记为 clean. WAL 是 append-only 的, 你就算重新 <code>write()</code> 同样的内容, page cache 认为这部分内容是 clean 的 (没有被修改), 不会重新标记为 dirty, 后续的 fsync 也不会触发任何刷盘操作. 数据就这样丢了, 无法恢复.</p>

<p>除非 WAL 路径改用 Direct I/O 或 <code>O_SYNC</code>/<code>O_DSYNC</code> – 在这些模式下, write 失败就是真的失败, 重试 write 就是真的重写, 不存在 page cache 状态不一致的问题.</p>

<h5 id="数据文件的-fsync-失败">数据文件的 fsync 失败</h5>

<p>数据文件和 WAL 有一个关键区别: WAL 是 append-only 的, 而数据文件是 in-place update 的. 这意味着数据文件的同一个 page 会被反复修改. 那么一个自然的问题是: fsync 失败后, 虽然内核把这些 page 标记成了 clean, 但既然数据文件的 page 是可以被重新修改的, 有没有办法通过重新写入这些 page, 让它们重新变成 dirty, 从而在下一次 fsync 时被刷到盘上?</p>

<p>这个思路理论上是可行的 – 毕竟对于 in-place update 的文件, 你对同一个 offset 重新 <code>write()</code>, 内核会把对应的 page 重新标记为 dirty. 这和 append-only 的 WAL 不一样: WAL 重新写同样的内容, page cache 认为没有修改; 但数据文件重新写同一个 page 的内容, page cache 会认为这是一次新的修改.</p>

<p>但深入分析后会发现, 要把这个思路落地, 面临一系列非常棘手的问题:</p>

<p><strong>哪些 page 需要重写?</strong> <code>fsync()</code> 返回的 EIO 只告诉你 “这个文件的某些 page 没刷成功”, 不告诉你具体是哪些 page. 要实现精确重试, PG 需要在 checkpoint 刷脏时额外记录 “本次 checkpoint 写出了哪些 page”, 这是目前没有的机制.</p>

<p><strong>shared buffers 中的状态已经不对了.</strong> 这些 page 在 shared buffers 中可能已经不再是 dirty 了 – 因为 <code>write()</code> 调用本身是成功的, PG 认为它们已经被写出到 page cache. 要重新刷这些 page, 需要在 shared buffers 中把它们重新标记为 dirty, 再重新 <code>write()</code> + <code>fsync()</code>. 但前面说了, PG 不知道哪些 page 受影响.</p>

<p><strong>buffer 替换问题.</strong> 即使你选择不推进 checkpoint LSN, 如果这些 page 在 shared buffers 中已经被标记为 clean, 它们可能被 buffer pool 的替换算法选中并 evict 掉. 一旦被 evict, 这些 page 的内存副本就丢了 – 盘上又是旧数据 – 最终还是只能从 WAL replay 来恢复, 这就等价于一次延迟的 PANIC + recovery.</p>

<p>要让 “不推进 + 重试” 在数据文件上真正工作, 你需要同时满足:</p>

<ol>
  <li>不推进 checkpoint LSN, 保留对应的 WAL</li>
  <li>记录本次 checkpoint 写出了哪些 page</li>
  <li>fsync 失败后把这些 page 在 shared buffers 中重新标记为 dirty</li>
  <li>这些 page 不允许被 evict (需要 pin 住)</li>
  <li>重新 <code>write()</code> + <code>fsync()</code> 来重试</li>
</ol>

<p>这实际上是一个运行时的 “mini crash recovery” – 复杂度很高. 而且即使实现了上述所有机制, 在 Buffered I/O 下仍然面临一个根本问题: 如果底层瞬态错误还没恢复, 下一次 fsync 可能又失败, page 又被标记为 clean, 陷入循环. 所以结论是: 虽然数据文件的 in-place update 特性在理论上给重试打开了一扇门, 但要真正走通这条路, 工程复杂度极高, 在 Buffered I/O 下很难做到可靠.</p>

<h5 id="根本出路-direct-io">根本出路: Direct I/O</h5>

<p>分析到这里, 结论其实很清楚: <strong>在 Buffered I/O 下, 无论是 WAL 还是数据文件, fsync 失败后的优雅重试都非常困难</strong> – 因为 page cache 的状态和 shared buffers 的状态都可能已经不一致了. PANIC 虽然粗暴, 但它通过 “回退到上一个成功的 checkpoint + WAL replay” 绕过了所有这些状态一致性问题.</p>

<p>要做到优雅重试, 最终还是绕不开 Direct I/O. 使用 <code>O_DIRECT</code> 时, <code>write()</code> 失败就是真的失败 (不存在 “write 成功但 fsync 失败” 的中间状态), 重试 <code>write()</code> 就是真的重写, 数据库对 I/O 的控制力完全不同. 这也是 MySQL/InnoDB 的做法 – <code>innodb_flush_method=O_DIRECT</code> 下, 数据文件的 I/O 不经过 page cache, 错误处理的语义清晰得多.</p>

<h5 id="云厂商的独特优势">云厂商的独特优势</h5>

<p>对于同时掌握存储层和数据库层的云厂商, 除了推动 Direct I/O 之外, 还有另一个维度的解法: 让存储层向数据库提供更丰富的错误语义 – 区分瞬态错误和永久性错误, 提供预计恢复时间, 甚至在存储层面实现 “transient-EIO-tolerant” 语义 (瞬态 EIO 在几秒内自动恢复时不向上层报错). 这是开源社区在一个盲盒般的 OS 存储栈上难以做到的事情.</p>

<h4 id="内核与数据库的沟通鸿沟">内核与数据库的沟通鸿沟</h4>

<h5 id="长期缺失的文档和指导">长期缺失的文档和指导</h5>

<p>2019 年 Linux Plumbers Conference 首次举办了 Databases 微型会议, SQLite 作者 Richard Hipp 和 PostgreSQL 的 Andres Freund 都在会上表达了对 Linux I/O 接口文档缺失的不满 [10].</p>

<p>Andres Freund 的发言直击要害: “如果 fsync 失败了重试会怎样? 原来的数据会被重试还是被丢弃? 应用开发者必须去读内核邮件列表的讨论帖才能搞清楚. 你不能在只有这么差的指导文档下还指责别人写了烂代码. “</p>

<h5 id="推荐阅读">推荐阅读</h5>

<p>以下资源有助于深入理解内核与数据库的交互问题:</p>

<ul>
  <li>LWN: “PostgreSQL’s fsync() surprise” (2018) [1]</li>
  <li>LWN: “Better guidance for database developers” (LPC 2019) [10]</li>
  <li>LWN: “A discussion between database and kernel developers” (LSFMM 2014) [11]</li>
  <li>LWN: “The end of block barriers” (2010) [12]</li>
  <li>Dan Luu: “Files are hard” and “Filesystem errors” series [13][14]</li>
  <li>OSDI 2014: “All File Systems Are Not Created Equal” [15]</li>
</ul>

<h4 id="总结">总结</h4>

<p>从 fsyncgate 到 LVM write barrier, 从 torn page 到 glibc locale 损坏, PostgreSQL 的历史反复说明了一个道理: 依赖 OS 层的隐式保证是危险的. 在本地存储时代, 这些问题被低错误率掩盖了; 在云原生时代, 它们被高频的瞬态 I/O 错误暴露无遗.</p>

<p>MySQL/InnoDB 的 <code>O_DIRECT</code> + Doublewrite Buffer 架构在这些问题上有天然优势, 但也并非完美. 真正的解决需要存储层和数据库层的协同演进: 更丰富的错误语义, 更精细的 I/O 控制, 以及对云存储瞬态错误的正确处理.</p>

<h4 id="参考资料">参考资料</h4>

<ol>
  <li>Jonathan Corbet, “PostgreSQL’s fsync() surprise”, LWN.net, April 2018. https://lwn.net/Articles/752063/</li>
  <li>PostgreSQL commit 9ccdd7f6, “PANIC on fsync() failure”, November 2018. https://www.postgresql.org/message-id/E1gObQY-00021d-L6@gemulon.postgresql.org</li>
  <li>Anthony Rebello et al., “Can Applications Recover from fsync Failures?”, USENIX ATC 2020 / ACM Transactions on Storage 2021. https://www.usenix.org/conference/atc20/presentation/rebello</li>
  <li>baotiao, “Claude Code 改写 PostgreSQL 内核, Full Page Write vs Doublewrite Buffer, 性能差 3 倍”, February 2026. https://baotiao.github.io/2026/02/05/fpw-dwb.html</li>
  <li>“LVM dangers and caveats”. https://www.baeldung.com/linux/logical-volume-management-problems</li>
  <li>PostgreSQL Wiki, “Corruption”. https://wiki.postgresql.org/wiki/Corruption</li>
  <li>PlanetScale, “The Real Failure Rate of EBS”, March 2025. https://planetscale.com/blog/the-real-fail-rate-of-ebs</li>
  <li>Hacker News discussion on EBS failure rates. https://news.ycombinator.com/item?id=43399811</li>
  <li>Zongzhi Chen, Xinjun Yang, et al., “CloudJump: Optimizing Cloud Database For Cloud Storage”, VLDB 2022. https://baotiao.github.io/2022/07/04/polardb-innodb.html</li>
  <li>Jonathan Corbet, “Better guidance for database developers”, LWN.net, LPC 2019. https://lwn.net/Articles/799807/</li>
  <li>Mel Gorman, “A discussion between database and kernel developers”, LWN.net, LSFMM 2014. https://lwn.net/Articles/590214/</li>
  <li>Jonathan Corbet, “The end of block barriers”, LWN.net, August 2010. https://lwn.net/Articles/400541/</li>
  <li>Dan Luu, “Files are hard”. https://danluu.com/file-consistency/</li>
  <li>Dan Luu, “Filesystem errors”. https://danluu.com/filesystem-errors/</li>
  <li>Thanumalayan Sankaranarayana Pillai et al., “All File Systems Are Not Created Equal: On the Complexity of Crafting Crash-Consistent Applications”, OSDI 2014.</li>
  <li>PostgreSQL Wiki, “Fsync Errors”. https://wiki.postgresql.org/wiki/Fsync_Errors</li>
  <li>Percona, “PostgreSQL fsync Failure Fixed – Minor Versions Released Feb 14, 2019”. https://www.percona.com/blog/postgresql-fsync-failure-fixed-minor-versions-released-feb-14-2019/</li>
  <li>USENIX, “Detecting Fail-Slow Failures in Large-Scale Cloud Storage Systems (PERSEUS)”, 2023. https://www.usenix.org/publications/loginonline/detecting-fail-slow-failures-large-scale-cloud-storage-systems</li>
</ol>]]></content><author><name>baotiao</name></author><category term="Other" /><summary type="html"><![CDATA[2018 年, PostgreSQL 社区发现了一个存在了 20 年的严重问题: 当 fsync() 失败时, PostgreSQL 的处理方式可能导致静默数据丢失. 这个被称为 “fsyncgate” 的事件, 不仅揭示了 PostgreSQL 自身的架构缺陷, 更暴露了 Linux 内核, 文件系统与数据库之间在 I/O 错误处理上的深层矛盾.]]></summary></entry><entry><title type="html">用 Claude Code 在 PostgreSQL 实现 Double Write Buffer 遇到的一些问题</title><link href="http://baotiao.github.io/2026/03/23/claude-dwb.html" rel="alternate" type="text/html" title="用 Claude Code 在 PostgreSQL 实现 Double Write Buffer 遇到的一些问题" /><published>2026-03-23T00:00:00+00:00</published><updated>2026-03-23T00:00:00+00:00</updated><id>http://baotiao.github.io/2026/03/23/claude-dwb</id><content type="html" xml:base="http://baotiao.github.io/2026/03/23/claude-dwb.html"><![CDATA[<p>最近一直在探索怎么用 Claude Code 来帮忙写数据库内核的代码.  一开始是直接让 Claude code 在 PostgreSQL 上实现一套 Double Write Buffer, 参考 InnoDB 的实现. 代码 Claude 确实写得挺快, 但过程中发现一个问题: 它不会做设计.</p>

<p><strong>Buffer I/O 和 Direct I/O 的差异</strong></p>

<p>我让 Claude 参考 InnoDB 的 DWB 实现方式, 在 PG 里面搞一份. 它很快就写出来了, 但其实有一个根本性的问题它完全没有意识到: InnoDB 是 Direct I/O, PostgreSQL 是 Buffer I/O.</p>

<p>在 InnoDB 里面, 因为是 Direct I/O, 脏页写到 DWB 之后 fsync 一次, 然后把脏页写到数据文件再 fsync 一次, 链路很清晰. 每次写入都是直接落盘的.</p>

<p>但 PG 不一样. PG 的刷脏只是把数据写到操作系统的 Page Cache 里面, 原来用的是 <code>sync_file_range</code>, 这个调用只是 “建议” 操作系统去刷盘, 并不保证一定成功. 以前有 Full Page Write 兜底, 所以这样没问题 — 即使 Page Cache 到磁盘写了一半 crash 了, WAL 里面有完整的页面镜像可以恢复.</p>

<p>但现在你要用 DWB 替代 FPW, 问题就来了. 脏页写到 DWB 并 fsync, 然后脏页通过 Buffer I/O 写到 Page Cache, 这时候 DWB 里面对应的 slot 就可以回收了. 但如果这时候还没来得及从 Page Cache 刷到磁盘就 crash 了呢? 脏页发生 partial write, DWB 里面的副本又已经被覆盖了, 那 DWB 就白写了.</p>

<p>所以在 Buffer I/O 下面, 脏页必须强制 fsync 到磁盘之后, DWB 的 slot 才能回收. 这一点和 InnoDB 的 Direct I/O 有本质区别, Claude 完全没考虑到.</p>

<p><strong>单进程刷脏跟不上</strong></p>

<p>这个问题是从上面那个问题推出来的.</p>

<p>PG 之所以只有一个 BG Writer 进程做刷脏, 是因为 Buffer I/O 下写脏页只是写到 Page Cache, 非常轻量, 一个进程就够了. Page Cache 到磁盘的刷盘是操作系统内核的多个线程并发去做的, 数据库不用管.</p>

<p>但你现在引入了 DWB, 每次写完脏页还得 fsync, 这就从一个轻量的 CPU 操作变成了重量级的 I/O 操作. 一个 BG Writer 做 fsync 显然跟不上. 理论上如果 Claude 懂设计的话, 它应该意识到需要把 BG Writer 改成多个进程并发刷脏. 但它没有, 只是在原来单进程的框架下面把 DWB 的写入逻辑塞进去了.</p>

<p><strong>多余的 Batch 策略</strong></p>

<p>InnoDB 在写 DWB 的时候会做 Batch 优化, 攒一批脏页一起写进去再 fsync, 摊薄 fsync 的开销. Claude 在 PG 的实现里面也照搬了这个策略.</p>

<p>但其实在 PG 里面这完全没必要. 因为上层的 <code>BufferSync</code> (Checkpointer 调的) 和 <code>BgBufferSync</code> (BG Writer 调的) 本身已经做了批量处理, 每次下来就是一批页面. 到 DWB 这一层的时候, 进来的已经是一批了, 没必要在 DWB 内部再加一层等待和攒批. 多一层 Batch 只会增加延迟和复杂度.</p>

<p><strong>怎么用 Claude 写内核代码</strong></p>

<p>这几个问题都不是代码 bug, 是设计上的问题. Claude 不理解 Buffer I/O 和 Direct I/O 在刷脏语义上的差异, 不会从 “需要 fsync” 推导出 “单进程跟不上, 需要多进程”, 也会机械地照搬参考实现里面的优化策略而不管目标系统里是不是已经有类似的机制.</p>

<p>所以目前比较靠谱的方式还是人做设计, Claude 做实现. 把关键的设计约束和架构决策想清楚, 让 Claude 在这个框架下面去写代码.</p>]]></content><author><name>baotiao</name></author><category term="Other" /><summary type="html"><![CDATA[最近一直在探索怎么用 Claude Code 来帮忙写数据库内核的代码. 一开始是直接让 Claude code 在 PostgreSQL 上实现一套 Double Write Buffer, 参考 InnoDB 的实现. 代码 Claude 确实写得挺快, 但过程中发现一个问题: 它不会做设计.]]></summary></entry><entry><title type="html">Claude Code 改写 PostgreSQL 内核, Full Page Write vs Doublewrite Buffer, 性能差 3 倍</title><link href="http://baotiao.github.io/2026/02/05/fpw-dwb.html" rel="alternate" type="text/html" title="Claude Code 改写 PostgreSQL 内核, Full Page Write vs Doublewrite Buffer, 性能差 3 倍" /><published>2026-02-05T00:00:00+00:00</published><updated>2026-02-05T00:00:00+00:00</updated><id>http://baotiao.github.io/2026/02/05/fpw-dwb</id><content type="html" xml:base="http://baotiao.github.io/2026/02/05/fpw-dwb.html"><![CDATA[<p>2026 年了, AI 能改数据库内核代码么? 我用 Claude Code 把 PostgreSQL 的 Full Page Write 换成了 MySQL 的 Doublewrite Buffer, 跑出来性能差了 3 倍.</p>

<h3 id="起因">起因</h3>

<p>FPW 和 DWB 到底哪个更合理, 这个问题我想了很久. 之前在 pgsql-hackers 的 mailing list 上发过<a href="https://www.postgresql.org/message-id/CAGbZs7hbJeUe7xY4QD25QW6VSnNFk1e3cwbCa8_R%2B2%2BYnoYRKw%40mail.gmail.com">一个帖子</a>讨论这事, 但没讨论出什么结果.</p>

<p>到了 2026 年, 正好想试试 Claude Code 能不能改内核代码, 顺便通过实际代码对比一下两种方案. Show me the code – 于是就有了这次实践.</p>

<h3 id="torn-page-问题">Torn Page 问题</h3>

<p>数据库以页为单位管理数据, PostgreSQL 默认 8KB, MySQL 默认 16KB. 但操作系统和磁盘的原子写入单元一般是 4KB.</p>

<p>这就意味着写一个完整的数据库页到磁盘, 需要多次物理 I/O. 如果写到一半断电了或者系统挂了, 页面就只写了一部分 – <strong>Torn Page</strong>, 新旧数据混在一起, 页面就坏了.</p>

<p>PostgreSQL 和 MySQL 用了完全不同的办法来解决这个问题.</p>

<h3 id="postgresql-full-page-write">PostgreSQL: Full Page Write</h3>

<p>每次 Checkpoint 之后, 某个数据页第一次被改的时候, PostgreSQL 把整个页的内容写到 WAL 里. 崩溃恢复时从 WAL 拿到完整页面覆盖掉坏的, 再回放后面的 WAL 记录就行了.</p>

<p>但 FPW 有个很要命的问题: <strong>它让 Checkpoint 频率变成了一个两难选择.</strong></p>

<p>FPW 希望少做 Checkpoint – 因为每次 Checkpoint 之后大量页面的首次修改都要写全页, WAL 体积暴涨, 写入性能断崖下跌. PostgreSQL 的 <code>checkpoint_timeout</code> 最低也得 30 秒, 当然了 checkpoint 还有可能是超过了 max_wal_size 的大小来触发.</p>

<p>但数据库理论又希望多做 Checkpoint – Checkpoint 越频繁, crash recovery 要回放的 WAL 越少, 恢复越快.</p>

<p>这俩需求是冲突的: <strong>FPW 要少做 Checkpoint, 快速恢复要多做 Checkpoint.</strong></p>

<h3 id="mysql-doublewrite-buffer">MySQL: Doublewrite Buffer</h3>

<p>InnoDB 的思路完全不一样. 刷脏页之前, 先把多个脏页顺序写到磁盘上一块专门的 Doublewrite Buffer 区域. 写满了再做一次 <code>fsync()</code>, 然后才把这些页面离散写到各自的数据文件位置.</p>

<p>crash 了怎么办? 重启时检查 Doublewrite Buffer 里有没有完整的页面副本, 有就拿来修复损坏的数据页. Torn Page 问题就不存在了.</p>

<h3 id="为什么我觉得-doublewrite-buffer-更合理">为什么我觉得 Doublewrite Buffer 更合理</h3>

<h4 id="前台-vs-后台">前台 vs 后台</h4>

<p>不考虑数据合并的话:</p>

<ul>
  <li>FPW = 1 次 WAL 写入 + 1 次数据页写入</li>
  <li>DWB = 2 次数据页写入</li>
</ul>

<p>都是 2 次 I/O, 但 WAL 写入是在前台路径上, 直接影响用户的 SQL latency; DWB 的写入在后台刷脏路径上, 用户基本感知不到.</p>

<h4 id="batch-优化空间不同">batch 优化空间不同</h4>

<p>DWB 不用每次写入都 <code>fsync()</code>, 写满一个 Buffer 才 sync 一次. WAL 写入虽然也能做 batch, 但毕竟是前台路径, 你不能让用户等太久, batch 空间有限.</p>

<h4 id="没有-checkpoint-频率的矛盾">没有 Checkpoint 频率的矛盾</h4>

<p>DWB 不依赖 Checkpoint 来防 Torn Page, 所以你可以随便提高 Checkpoint 频率来加速 crash recovery, 不会有写放大的副作用.</p>

<h3 id="性能测试">性能测试</h3>

<p>主要配置:</p>

<pre><code>shared_buffers=4GB
wal_buffers=64MB
synchronous_commit=on
maintenance_work_mem=2GB
checkpoint_timeout=30s
</code></pre>

<p>每个场景重建数据库, 跑之前做一次 <code>VACUUM FULL</code> 加 60 秒预热, 每个负载跑 300 秒.</p>

<p>场景: io-bound, –tables=10 –table_size=10000000</p>

<p>结果如下:</p>

<p><img src="https://raw.githubusercontent.com/baotiao/bb/main/uPic/image.png" alt="image" /></p>

<table>
  <thead>
    <tr>
      <th>场景</th>
      <th>并发</th>
      <th>FPW OFF (QPS)</th>
      <th>FPW ON (QPS)</th>
      <th>DWB ON (QPS)</th>
      <th>FPW OFF (TPS)</th>
      <th>FPW ON (TPS)</th>
      <th>DWB ON (TPS)</th>
      <th>FPW OFF (ms)</th>
      <th>FPW ON (ms)</th>
      <th>DWB ON (ms)</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>read_write</td>
      <td>32</td>
      <td>360,764</td>
      <td>158,865</td>
      <td>260,171</td>
      <td>18,038</td>
      <td>7,943</td>
      <td>13,009</td>
      <td>1.77</td>
      <td>4.03</td>
      <td>2.46</td>
    </tr>
    <tr>
      <td>read_write</td>
      <td>64</td>
      <td>484,988</td>
      <td>190,654</td>
      <td>307,735</td>
      <td>24,249</td>
      <td>9,533</td>
      <td>15,387</td>
      <td>2.64</td>
      <td>6.71</td>
      <td>4.16</td>
    </tr>
    <tr>
      <td>read_write</td>
      <td>128</td>
      <td>556,021</td>
      <td>194,301</td>
      <td>301,791</td>
      <td>27,801</td>
      <td>9,715</td>
      <td>15,387</td>
      <td>4.60</td>
      <td>13.17</td>
      <td>9.81</td>
    </tr>
    <tr>
      <td>write_only</td>
      <td>32</td>
      <td>318,879</td>
      <td>108,696</td>
      <td>188,760</td>
      <td>53,146</td>
      <td>18,116</td>
      <td>31,460</td>
      <td>0.60</td>
      <td>1.77</td>
      <td>1.02</td>
    </tr>
    <tr>
      <td>write_only</td>
      <td>64</td>
      <td>345,766</td>
      <td>117,533</td>
      <td>197,251</td>
      <td>57,628</td>
      <td>19,589</td>
      <td>32,875</td>
      <td>1.11</td>
      <td>3.27</td>
      <td>1.95</td>
    </tr>
    <tr>
      <td>write_only</td>
      <td>128</td>
      <td>356,725</td>
      <td>89,144</td>
      <td>202,884</td>
      <td>59,454</td>
      <td>14,857</td>
      <td>33,814</td>
      <td>2.15</td>
      <td>8.61</td>
      <td>3.78</td>
    </tr>
  </tbody>
</table>

<p>结果很明显: 关掉 FPW 性能最好作为基线, 开了 FPW 之后性能掉到基线的 ~25%, 而 DWB 能保持 ~57%. write_only 128 并发的场景下 DWB 是 FPW 吞吐的 2.3 倍, 延迟也全面优于 FPW.</p>

<h3 id="代码">代码</h3>

<p>改好的代码在这: <a href="https://github.com/baotiao/postgres">https://github.com/baotiao/postgres</a></p>

<p>整个内核改动是用 Claude Code 完成的, 算是验证了一下 AI 改数据库内核代码这事确实能干.</p>

<p>BTW: 欢迎关注 <a href="https://github.com/alibaba/AliSQL">AliSQL</a> <strong>Alibaba’s Enterprise MySQL Branch with DuckDB OLAP &amp; Native Vector Search</strong></p>]]></content><author><name>baotiao</name></author><category term="Other" /><summary type="html"><![CDATA[2026 年了, AI 能改数据库内核代码么? 我用 Claude Code 把 PostgreSQL 的 Full Page Write 换成了 MySQL 的 Doublewrite Buffer, 跑出来性能差了 3 倍.]]></summary></entry><entry><title type="html">为什么我认为 MySQL 比 PostgreSQL 集成 DuckDB 更加的优雅?</title><link href="http://baotiao.github.io/2026/02/04/mysql-duckdb.html" rel="alternate" type="text/html" title="为什么我认为 MySQL 比 PostgreSQL 集成 DuckDB 更加的优雅?" /><published>2026-02-04T00:00:00+00:00</published><updated>2026-02-04T00:00:00+00:00</updated><id>http://baotiao.github.io/2026/02/04/mysql-duckdb</id><content type="html" xml:base="http://baotiao.github.io/2026/02/04/mysql-duckdb.html"><![CDATA[<p>我们看到目前有 3 个主流 PostgreSQL 集成 DuckDB 的方案在运行 pg_duckdb,pg_mooncake, pg_lake.</p>

<p>pg_duckdb 是官方提供的 DuckDB 插件, 只能提供存量行存表到 DuckDB 的迁移, 无法让增量的数据同步到 DuckDB 表中, 适用场景比较受限.</p>

<p>databricks 收购的 pg_mooncake 可以支持存量和增量的数据同步, 通过额外的 pg_moonlink 进程以逻辑复制的方式把 PostgreSQL 的数据复制过来, 并且以 Iceberg 格式写入, 后续如果有复制查询, 需要走 postgresql =&gt; pg_moonlink =&gt; s3(Iceberg) 的请求方式.</p>

<p>snowflake 收购的 pg_lake 同样也不支持增量数据同步, 只支持全量的数据导入导出, 感觉更多是一个归档场景的方案.</p>

<p>我们可以看到有几个问题, 一个是 PostgreSQL 逻辑复制能力不够成熟, 远不及其原生的物理复制能力, 无法通过逻辑复制连接PostgreSQL和DuckDB只读实例.
另外一个问题是 PostgreSQL 没有支持很好的可插拔的存储引擎能力, 虽然 PostgreSQL 提供了 table access method 作为存储引擎接口, 但并没有提供主备复制, Crash Recovery等能力, 很多场景下无法保证数据一致性.</p>

<p><strong>在 MySQL 里面很好的解决了这个问题</strong></p>

<p>首先 MySQL 天然就是一个可插拔的存储引擎设计, 在早期 MySQL 的默认引擎还是 MyIsam, 后面由于 InnoDB 对行级别 MVCC 的支持, MySQL 才把默认的引擎转换成了 InnoDB 引擎. 在 MySQL 里面原先也有InfoBright 这样的列存方案, 但是没有流行起来. 所以在 MySQL 里面支持列存 DuckDB, 增加一个列存引擎是一个非常顺其自然的事情. 不需要像 PostgreSQL 一样, 需要将写入数据先写入到行存再转换成列存这样的解决方案.</p>

<p>另外是 MySQL 的 binlog 机制, MySQL 的双 log 机制有缺点也有优点, binlog/redo log 的存在肯定会对写入性能造成影响, 但是 binlog 对 MySQL 生态的上下游提供了非常好的支持, binlog 提供了完整的 SQL 语句非常方便复制给下游, 这也是为什么 MySQL 生态的 OLAP 应用这么流行的原因, 像 Clickhouse, starrocks, selectdb 等等.</p>

<p>MySQL 使用 DuckDB 作为存储引擎场景里面, MySQL 的 binlog 生态是完全兼容, 没有被破坏的. 所以它可以作为一个数仓节点, 写入到这个数仓节点的数据依然可以把 binlog 流转出来. 在作为 HTAP 的场景里面, 主节点 MySQL innodb 引擎发送 binlog 到下游的 MySQL DuckDB 引擎, 从而实现完全兼容的流转.</p>]]></content><author><name>baotiao</name></author><category term="Other" /><summary type="html"><![CDATA[我们看到目前有 3 个主流 PostgreSQL 集成 DuckDB 的方案在运行 pg_duckdb,pg_mooncake, pg_lake.]]></summary></entry></feed>