1
# 存储层级的核心设计策略
2
strategies = {
3
    "缓存（Caching）": "将热数据放在更快的层级，减少慢速层访问",
4
    "预取（Prefetching）": "预测未来需要的数据，提前加载到快速层",
5
    "批处理（Batching）": "将多个小 I/O 合并为大 I/O，摊销延迟开销",
6
    "压缩（Compression）": "减少数据量，降低传输和存储开销",
7
    "索引（Indexing）": "用额外的空间换取查找速度，避免全量扫描",
8
    "顺序化（Sequential）": "将随机 I/O 转化为顺序 I/O，利用磁盘带宽",
9
}

1
// 存储引擎核心组件的抽象接口
2
struct StorageEngine {
3
    // 写路径组件
4
    WAL         *wal;           // 预写日志，保证持久性
5
    MemTable    *memtable;      // 内存中的有序写入缓冲
6
    MemTable    *immutable;     // 正在刷盘的只读 MemTable
7

8
    // 读路径组件
9
    BlockCache  *cache;         // 块级缓存
10
    BloomFilter *bloom;         // 布隆过滤器，减少无效 I/O
11

12
    // 持久化组件
13
    SSTable     *levels[];      // 多层级 SSTable 文件
14
    Compactor   *compactor;     // 后台 Compaction 线程
15

16
    // 事务组件
17
    VersionSet  *versions;      // 版本管理（MVCC）
18
    LockManager *locks;         // 并发控制
19
};

1
# 写放大示例：LSM 树的 Compaction
2
# 假设用户写入 1MB 数据
3
user_write = 1  # MB
4

5
# Level 0 → Level 1: 重写 1MB
6
# Level 1 → Level 2: 重写 10MB
7
# Level 2 → Level 3: 重写 100MB
8
total_disk_write = user_write * (1 + 10 + 100)  # = 111MB
9

10
write_amplification = total_disk_write / user_write  # = 111x
11
print(f"写放大: {write_amplification}x")

1
# 写路径关键步骤及延迟估算
2
write_path_steps = {
3
    "1. WAL 写入": "~10 μs (NVMe 顺序写)",
4
    "2. MemTable 更新": "~0.1 μs (内存跳表插入)",
5
    "3. WAL 刷盘（提交）": "~10 μs (fsync/fdatasync)",
6
    "4. MemTable → SSTable": "~1 ms (后台 Flush, 异步)",
7
    "5. Compaction": "~10 ms–1 s (后台, 异步)",
8
}
9
# 同步延迟：步骤 1+2+3 ≈ 20 μs（用户感知的写入延迟）
10
# 异步延迟：步骤 4+5 在后台执行，不阻塞用户写入

1
# 查看块设备信息
2
lsblk -o NAME,SIZE,TYPE,MOUNTPOINT,ROTA
3
# ROTA=1 表示旋转设备(HDD), ROTA=0 表示非旋转设备(SSD)
4

5
# 查看 I/O 调度器
6
cat /sys/block/sda/queue/scheduler
7

8
# 查看页面缓存统计
9
cat /proc/meminfo | grep -i "cache\|buffer"
10

11
# 使用 iostat 观察 I/O 统计
12
iostat -x 1 5
13

14
# 使用 perf 观察 I/O 延迟分布
15
perf stat -e 'block:block_rq_issue,block:block_rq_complete' -a sleep 10

1
-- MySQL: 观察 InnoDB 状态
2
SHOW ENGINE INNODB STATUS\G
3

4
-- 观察 Buffer Pool 命中率
5
SHOW STATUS LIKE 'Innodb_buffer_pool_read%';
6
-- Innodb_buffer_pool_read_requests /
7
-- (Innodb_buffer_pool_read_requests + Innodb_buffer_pool_reads)
8

9
-- 观察页面刷新统计
10
SHOW STATUS LIKE 'Innodb_data_written';
11
SHOW STATUS LIKE 'Innodb_os_log_written';

1
-- PostgreSQL: 观察缓冲区统计
2
SELECT
3
    sum(heap_blks_read) AS heap_read,
4
    sum(heap_blks_hit) AS heap_hit,
5
    sum(heap_blks_hit) / NULLIF(sum(heap_blks_hit + heap_blks_read), 0)
6
        AS cache_hit_ratio
7
FROM pg_statio_user_tables;
8

9
-- 观察 WAL 写入量
10
SELECT pg_size_pretty(pg_wal_lsn_diff(pg_current_wal_lsn(), '0/0')) AS wal_written;

1
# 使用 bcc 工具观察 I/O 延迟分布
2
# biolatency - I/O 延迟直方图
3
/usr/share/bcc/tools/biolatency 1 10
4

5
# 输出示例：
6
#      usecs           : count    distribution
7
#          0 -> 1      : 0        |                                      |
8
#          2 -> 3      : 0        |                                      |
9
#          4 -> 7      : 0        |                                      |
10
#          8 -> 15     : 12       |******                                |
11
#         16 -> 31     : 45       |**********************                |
12
#         32 -> 63     : 89       |****************************************|
13
#         64 -> 127    : 23       |***********                           |
14
#        128 -> 255    : 5        |**                                    |