1
// WAL 写入流程（简化）
2
struct WALWriter {
3
    int         fd;             // WAL 文件描述符
4
    uint64_t    current_offset; // 当前写入偏移
5
    buffer_t    write_buffer;  // 写入缓冲
6
    mutex_t     write_mutex;    // 写入互斥锁
7
    cond_t      write_cond;    // 写入条件变量
8
};
9

10
void wal_append(WALWriter *wal, WriteBatch *batch) {
11
    // 1. 序列化 WriteBatch
12
    wal_record_t record;
13
    record.length = serialize_batch(batch, record.data);
14
    record.crc = crc32(record.data, record.length);
15

16
    // 2. 追加到写入缓冲
17
    mutex_lock(&wal->write_mutex);
18
    buffer_append(&wal->write_buffer, &record, sizeof(record));
19

20
    // 3. Group Commit：等待一小段时间，合并多个写入
21
    // 详见第三节
22

23
    // 4. 刷盘（fdatasync）
24
    write(wal->fd, wal->write_buffer.data, wal->write_buffer.size);
25
    fdatasync(wal->fd);  // 确保数据落盘
26

27
    // 5. 清空缓冲
28
    buffer_clear(&wal->write_buffer);
29
    mutex_unlock(&wal->write_mutex);
30
}

1
// WAL 记录格式
2
struct WALRecord {
3
    uint32_t  crc;           // CRC32 校验
4
    uint32_t  length;        // 数据长度
5
    uint64_t  lsn;           // 日志序列号
6
    uint8_t   type;          // 记录类型
7
    uint8_t   data[];        // 变长数据
8
};
9

10
// 记录类型
11
enum WALRecordType {
12
    FULL_RECORD    = 0,   // 完整记录
13
    FIRST_FRAGMENT = 1,   // 分片：第一片
14
    MIDDLE_FRAGMENT = 2,  // 分片：中间片
15
    LAST_FRAGMENT  = 3,   // 分片：最后一片
16
    CHECKPOINT     = 4,   // 检查点
17
};
18

19
// InnoDB Redo Log 记录格式
20
struct RedoLogRecord {
21
    uint8_t   type;          // 操作类型（INSERT/UPDATE/DELETE...）
22
    uint32_t  space_id;      // 表空间 ID
23
    uint32_t  page_no;       // 页面编号
24
    uint16_t  offset;        // 页内偏移
25
    uint8_t   data[];        // 变长数据
26
};

1
// Group Commit 实现（简化）
2
struct GroupCommitQueue {
3
    mutex_t     mutex;
4
    cond_t      cond;
5
    WriteBatch *batches[MAX_BATCH];
6
    int         count;
7
};
8

9
void group_commit_submit(GroupCommitQueue *queue, WriteBatch *batch) {
10
    mutex_lock(&queue->mutex);
11
    queue->batches[queue->count++] = batch;
12

13
    if (queue->count == 1) {
14
        // 第一个事务：启动 Group Commit 窗口
15
        // 等待更多事务加入（通常 100μs–1ms）
16
        cond_timedwait(&queue->cond, &queue->mutex, GROUP_COMMIT_TIMEOUT);
17

18
        // 窗口关闭，执行 Group Commit
19
        do_group_commit(queue);
20
    } else {
21
        // 后续事务：等待 Leader 完成 fsync
22
        while (!batch->committed) {
23
            cond_wait(&queue->cond, &queue->mutex);
24
        }
25
    }
26
    mutex_unlock(&queue->mutex);
27
}
28

29
void do_group_commit(GroupCommitQueue *queue) {
30
    // 1. 合并所有 WriteBatch
31
    buffer_t combined;
32
    for (int i = 0; i < queue->count; i++) {
33
        serialize_batch(&combined, queue->batches[i]);
34
    }
35

36
    // 2. 一次写入 + fsync
37
    write(wal_fd, combined.data, combined.size);
38
    fdatasync(wal_fd);
39

40
    // 3. 通知所有等待的事务
41
    for (int i = 0; i < queue->count; i++) {
42
        queue->batches[i]->committed = true;
43
    }
44
    cond_broadcast(&queue->cond);
45
    queue->count = 0;
46
}

1
// InnoDB 写入流程（简化）
2
void innodb_write_row(dict_index_t *index, dtuple_t *row, trx_t *trx) {
3
    // 1. 开启事务
4
    trx_start(trx);
5

6
    // 2. 加行锁
7
    lock_table(row->table, LOCK_X);
8

9
    // 3. 写 Undo Log（用于回滚和 MVCC）
10
    undo_log_write(trx, UNDO_INSERT, row);
11

12
    // 4. 在 B+ 树中插入记录
13
    // 4a. 查找目标页面
14
    page_t *page = btree_search(index, row->key);
15

16
    // 4b. 修改页面（在 Buffer Pool 中）
17
    page_insert(page, row);
18
    page_mark_dirty(page);
19

20
    // 5. 写 Redo Log（WAL）
21
    // 记录页面的物理变更
22
    redo_log_write(REDOPAGE_INSERT, page->id, row->offset, row->data);
23

24
    // 6. 提交事务
25
    // Group Commit：等待 fsync
26
    trx_commit(trx);
27

28
    // 后台操作：
29
    // - 脏页刷盘（由 Page Cleaner 线程负责）
30
    // - Doublewrite（防止页面写撕裂）
31
    // - Purge（清理 Undo Log）
32
}

1
// RocksDB 写入流程（简化）
2
void rocksdb_put(DB *db, const Slice &key, const Slice &value) {
3
    // 1. 构造 WriteBatch
4
    WriteBatch batch;
5
    batch.Put(key, value);
6

7
    // 2. 获取写锁（所有写入串行化）
8
    mutex_lock(&db->write_mutex);
9

10
    // 3. 写入 WAL（如果启用）
11
    if (db->options.write_options.sync) {
12
        wal_append(db->wal, batch);
13
        fdatasync(db->wal_fd);
14
    }
15

16
    // 4. 写入 MemTable
17
    memtable_insert(db->memtable, key, value, db->next_seq++);
18

19
    // 5. 检查是否需要 Flush
20
    if (memtable_size(db->memtable) >= db->options.write_buffer_size) {
21
        // 5a. 将当前 MemTable 切换为 Immutable
22
        db->immutable = db->memtable;
23
        db->memtable = memtable_create();
24

25
        // 5b. 通知后台线程 Flush
26
        schedule_flush(db);
27
    }
28

29
    // 6. 释放写锁
30
    mutex_unlock(&db->write_mutex);
31
}

1
# RocksDB 写入停顿机制
2
def check_write_stall(db):
3
    l0_file_count = len(db.levels[0].sstables)
4
    l1_size = db.levels[1].total_size
5
    l1_max = db.options.max_bytes_for_level_base
6

7
    # L0 文件数过多
8
    if l0_file_count >= db.options.level0_stop_writes_trigger:
9
        return "STOP"  # 完全停止写入
10

11
    if l0_file_count >= db.options.level0_slowdown_writes_trigger:
12
        return "SLOW"  # 写入前 sleep 1ms
13

14
    # L1 大小超过限制
15
    if l1_size >= l1_max * db.options.level1_size_limit:
16
        return "SLOW"
17

18
    return "OK"
19

20
# 默认配置
21
# level0_slowdown_writes_trigger = 20
22
# level0_stop_writes_trigger = 36
23
# 当 L0 有 20+ 个 SSTable 时，写入延迟增加
24
# 当 L0 有 36+ 个 SSTable 时，写入完全停止

1
# 刷盘策略对性能的影响
2
def analyze_flush_strategy():
3
    scenarios = {
4
        "每次提交 fsync": {
5
            "latency": "1–5ms（取决于磁盘）",
6
            "throughput": "~1000 TPS（单线程）",
7
            "durability": "最强",
8
        },
9
        "每秒 fsync": {
10
            "latency": "0.1–0.5ms",
11
            "throughput": "~10000 TPS",
12
            "durability": "可能丢失 1 秒数据",
13
        },
14
        "Group Commit fsync": {
15
            "latency": "0.5–2ms",
16
            "throughput": "~50000+ TPS",
17
            "durability": "强（所有提交的事务都持久化）",
18
        },
19
        "不 fsync": {
20
            "latency": "0.01–0.1ms",
21
            "throughput": "~100000+ TPS",
22
            "durability": "弱（可能丢失数据）",
23
        },
24
    }
25
    for name, info in scenarios.items():
26
        print(f"{name:25s} | 延迟: {info['latency']:15s} | "
27
              f"吞吐: {info['throughput']:15s} | 持久性: {info['durability']}")
28

29
analyze_flush_strategy()

1
-- InnoDB 写入相关配置
2
-- WAL 刷盘策略
3
SET GLOBAL innodb_flush_log_at_trx_commit = 1;  -- 最安全
4
-- 1: 每次提交 fsync（默认，最安全）
5
-- 2: 每次提交写入 OS 缓冲，每秒 fsync
6
-- 0: 每秒写入并 fsync（最快，可能丢数据）
7

8
-- Doublewrite
9
SET GLOBAL innodb_doublewrite = 1;  -- 建议开启
10

11
-- 刷盘方法
12
SET GLOBAL innodb_flush_method = O_DIRECT;  -- 推荐
13

14
-- 脏页刷盘比例
15
SET GLOBAL innodb_max_dirty_pages_pct = 75;
16
SET GLOBAL innodb_max_dirty_pages_pct_lwm = 10;
17

18
-- 刷盘频率
19
SET GLOBAL innodb_io_capacity = 2000;        -- SSD 推荐
20
SET GLOBAL innodb_io_capacity_max = 4000;    -- SSD 推荐

1
# RocksDB 写入相关配置
2
# WAL 模式
3
# WAL_sync: 每次写入 fsync WAL（最安全）
4
# WAL_async: 异步 fsync
5
# WAL_disable: 不写 WAL（最快，崩溃丢数据）
6

7
# Write Buffer 大小
8
write_buffer_size = 67108864  # 64MB
9

10
# 最大 Write Buffer 数量
11
max_write_buffer_number = 3
12

13
# Write Buffer 总大小限制
14
db_write_buffer_size = 268435456  # 256MB
15

16
# 后台 Flush 线程数
17
max_background_flushes = 2
18

19
# 后台 Compaction 线程数
20
max_background_compactions = 4
21

22
# 写入限速
23
rate_limiter_bytes_per_sec = 104857600  # 100MB/s

1
-- 观察 WAL 写入量
2
SHOW STATUS LIKE 'Innodb_os_log_written';
3

4
-- 观察脏页比例
5
SHOW STATUS LIKE 'Innodb_buffer_pool_pages_dirty';
6
SHOW STATUS LIKE 'Innodb_buffer_pool_pages_total';
7

8
-- 观察刷盘统计
9
SHOW STATUS LIKE 'Innodb_data_writes';
10
SHOW STATUS LIKE 'Innodb_data_written';
11
SHOW STATUS LIKE 'Innodb_fsyncs';
12

13
-- 观察 Doublewrite 统计
14
SHOW STATUS LIKE 'Innodb_dblwr%';

1
# RocksDB 统计信息
2
# 通过 db.GetProperty() 获取
3
rocksdb.stats
4

5
# 关键指标：
6
# wal.bytes_written:         WAL 写入字节数
7
# wal.syncs:                 WAL fsync 次数
8
# memtable.insert:           MemTable 插入次数
9
# memtable.flush:           Flush 次数
10
# compaction.bytes_written:  Compaction 写入字节数
11
# stall.micros:              写入停顿时间

1
# 使用 perf 分析写入延迟
2
perf record -e 'block:block_rq_issue,block:block_rq_complete' \
3
    -p $(pidof mysqld) sleep 10
4
perf report
5

6
# 使用 bcc 分析 fsync 延迟
7
/usr/share/bcc/tools/xfsslower 10
8
# Tracing XFS operations slower than 10 ms
9

10
# 使用 strace 跟踪 fsync 调用
11
strace -e fdatasync,fsync -p $(pidof mysqld) -c