1
// Buffer Pool 核心数据结构
2
struct BufferPool {
3
    // 页面哈希表：page_id → buffer_block
4
    hash_table_t *page_hash;
5

6
    // LRU 列表（改进型）
7
    struct {
8
        ut_list_base(buf_page_t) young;  // 热数据（前 5/8）
9
        ut_list_base(buf_page_t) old;    // 冷数据（后 3/8）
10
    } lru;
11

12
    // 脏页列表
13
    ut_list_base(buf_page_t) flush_list;
14

15
    // 空闲页列表
16
    ut_list_base(buf_page_t) free_list;
17

18
    // 统计信息
19
    uint64_t stat_n_page_reads;     // 读取次数
20
    uint64_t stat_n_page_read_hits; // 命中次数
21
};
22

23
// 缓冲块
24
struct buf_block_t {
25
    page_id_t   page_id;       // 页面 ID
26
    byte       *frame;         // 数据帧（16KB）
27
    lsn_t       newest_lsn;    // 最新修改 LSN
28
    bool        is_dirty;      // 是否脏页
29
    buf_page_state_t state;    // 状态
30
    rw_lock_t   lock;          // 读写锁
31
};

1
// InnoDB LRU 操作
2
void buf_page_accessed(buf_block_t *block) {
3
    if (block->in_old_list) {
4
        // 页面在 Old 子列表
5
        // 检查是否在 Old 列表停留足够长时间
6
        if (time_since_first_access(block) > innodb_old_blocks_time) {
7
            // 停留时间足够长，移到 Young 子列表头部
8
            move_to_young_head(block);
9
            block->in_old_list = false;
10
        }
11
        // 否则留在 Old 子列表（防止全表扫描污染）
12
    } else {
13
        // 页面在 Young 子列表
14
        // 移到 Young 子列表头部
15
        move_to_young_head(block);
16
    }
17
}

1
# 2Q（Two Queues）算法
2
class TwoQ:
3
    def __init__(self, capacity):
4
        self.capacity = capacity
5
        self.a1_in = []      # 最近访问队列（FIFO）
6
        self.a1_out = []     # 最近驱逐队列（只存 Key）
7
        self.am = OrderedDict()  # 频繁访问队列（LRU）
8

9
        self.a1_in_max = int(capacity * 0.25)  # A1in 占 25%
10
        self.am_max = int(capacity * 0.75)     # Am 占 75%
11

12
    def get(self, key):
13
        if key in self.am:
14
            # 命中 Am：移到头部
15
            self.am.move_to_end(key)
16
            return self.am[key]
17

18
        if key in self.a1_out:
19
            # 命中 A1out：提升到 Am（第二次访问）
20
            self.a1_out.remove(key)
21
            self.am[key] = load_from_disk(key)
22
            self.am.move_to_end(key)
23
            self._evict_if_needed()
24
            return self.am[key]
25

26
        # 未命中：从磁盘读取，放入 A1in
27
        self.a1_in.append(key)
28
        self._evict_if_needed()
29
        return load_from_disk(key)
30

31
    def _evict_if_needed(self):
32
        # A1in 满了：移到 A1out
33
        if len(self.a1_in) > self.a1_in_max:
34
            old_key = self.a1_in.pop(0)
35
            self.a1_out.append(old_key)
36

37
        # A1out 满了：丢弃最旧的
38
        while len(self.a1_out) > self.a1_in_max:
39
            self.a1_out.pop(0)
40

41
        # Am 满了：LRU 淘汰
42
        while len(self.am) > self.am_max:
43
            self.am.popitem(last=False)

1
# InnoDB 自适应刷盘算法
2
def adaptive_flushing(dirty_page_ratio, redo_generation_rate,
3
                       io_capacity):
4
    """自适应刷盘速率"""
5
    # 基于脏页比例
6
    flush_rate_by_ratio = dirty_page_ratio * io_capacity * 2
7

8
    # 基于 Redo Log 生成速率
9
    # 如果 Redo 生成很快，需要加速刷盘以推进检查点
10
    flush_rate_by_lsn = redo_generation_rate * 1.1
11

12
    # 取较大值
13
    flush_rate = max(flush_rate_by_ratio, flush_rate_by_lsn)
14

15
    # 不超过最大 I/O 容量
16
    flush_rate = min(flush_rate, io_capacity * 2)
17

18
    return flush_rate

1
// InnoDB Doublewrite 流程
2
void buf_flush_page(buf_block_t *block) {
3
    // 1. 写入 Doublewrite Buffer
4
    //    Doublewrite 是共享表空间中 2MB 的连续区域
5
    //    可以容纳 128 个页面（128 × 16KB = 2MB）
6
    doublewrite_write(block);
7
    fdatasync(doublewrite_fd);  // 确保 Doublewrite 先落盘
8

9
    // 2. 写入数据文件
10
    pwrite(block->file_fd, block->frame, PAGE_SIZE, block->offset);
11
    fdatasync(block->file_fd);
12

13
    // 3. 标记为干净页
14
    block->is_dirty = false;
15

16
    // 崩溃恢复时：
17
    // 如果数据文件中的页面损坏（torn page）
18
    // 从 Doublewrite Buffer 恢复完整页面
19
}

1
-- InnoDB 预读配置
2
-- 线性预读阈值
3
SET GLOBAL innodb_read_ahead_threshold = 56;
4
-- 一个 Extent（64 页）中有 56 页被顺序访问时触发预读
5

6
-- 随机预读（通常关闭）
7
SET GLOBAL innodb_random_read_ahead = 0;

1
// Buffer Pool Instance 分片
2
// page_id % innodb_buffer_pool_instances 决定使用哪个 Instance
3

4
int get_buffer_pool_instance(page_id_t page_id) {
5
    return page_id % innodb_buffer_pool_instances;
6
}
7

8
// 每个 Instance 有独立的：
9
// - LRU List
10
// - Flush List
11
// - Free List
12
// - Page Hash
13
// - 互斥锁
14

15
// 推荐配置：
16
// Instance 数量 = CPU 核心数 / 2（最多 64）

1
// Buffer Pool 页面锁
2
struct buf_block_t {
3
    // 读写锁：保护页面内容
4
    rw_lock_t   lock;       // S 锁（读）/ X 锁（写）
5

6
    // 互斥锁：保护页面元数据
7
    mutex_t     mutex;      // 保护 state, is_dirty 等
8
};
9

10
// 获取页面的流程
11
buf_block_t *buf_page_get(page_id_t page_id, rw_lock_mode_t mode) {
12
    // 1. 在 Page Hash 中查找
13
    buf_block_t *block = hash_search(page_id);
14

15
    if (block == NULL) {
16
        // 2. 未命中：从磁盘读取
17
        block = buf_read_page(page_id);
18
    }
19

20
    // 3. 固定页面（防止被淘汰）
21
    block->fix_count++;
22

23
    // 4. 获取页面锁
24
    if (mode == RW_S_LOCK) {
25
        rw_lock_s_lock(&block->lock);
26
    } else {
27
        rw_lock_x_lock(&block->lock);
28
    }
29

30
    return block;
31
}

1
-- Buffer Pool 命中率
2
SELECT
3
    (1 - Innodb_buffer_pool_reads / Innodb_buffer_pool_read_requests) * 100
4
    AS hit_ratio
5
FROM (
6
    SELECT variable_value + 0 AS Innodb_buffer_pool_reads
7
    FROM performance_schema.global_status
8
    WHERE variable_name = 'Innodb_buffer_pool_reads'
9
) r,
10
(
11
    SELECT variable_value + 0 AS Innodb_buffer_pool_read_requests
12
    FROM performance_schema.global_status
13
    WHERE variable_name = 'Innodb_buffer_pool_read_requests'
14
) rr;
15

16
-- 目标：命中率 > 99.5%
17
-- 如果低于 99%，考虑增加 Buffer Pool 大小
18

19
-- Buffer Pool 使用情况
20
SELECT
21
    page_type,
22
    SUM(data_size) / 1024 / 1024 AS size_mb,
23
    COUNT(*) AS page_count
24
FROM performance_schema.innodb_buffer_page
25
GROUP BY page_type
26
ORDER BY size_mb DESC;

1
-- PostgreSQL shared_buffers
2
-- 推荐：物理内存的 25%
3
-- shared_buffers = '16GB'
4

5
-- 查看缓冲区统计
6
SELECT
7
    sum(heap_blks_hit) AS hits,
8
    sum(heap_blks_read) AS reads,
9
    sum(heap_blks_hit) / NULLIF(sum(heap_blks_hit + heap_blks_read), 0)
10
        AS hit_ratio
11
FROM pg_statio_user_tables;
12

13
-- 目标：命中率 > 99%

1
-- InnoDB Buffer Pool 状态
2
SHOW ENGINE INNODB STATUS\G
3

4
-- 关键信息：
5
-- Buffer pool size: 262144 pages (4GB)
6
-- Free buffers:     1024 pages
7
-- Database pages:   261120 pages
8
-- Old database pages: 96614 pages
9
-- Modified db pages:  15234 pages
10
-- Buffer pool hit rate: 1000 / 1000
11
-- Young-making: 1234567
12
-- Not young-making: 876543

1
-- 查看最热的索引页面
2
SELECT
3
    table_name,
4
    index_name,
5
    COUNT(*) AS page_count,
6
    SUM(data_size) / 1024 / 1024 AS size_mb
7
FROM performance_schema.innodb_buffer_page
8
WHERE table_name IS NOT NULL
9
GROUP BY table_name, index_name
10
ORDER BY page_count DESC
11
LIMIT 20;

1
-- 脏页统计
2
SHOW STATUS LIKE 'Innodb_buffer_pool_pages_dirty';
3
SHOW STATUS LIKE 'Innodb_buffer_pool_pages_total';
4

5
-- 刷盘统计
6
SHOW STATUS LIKE 'Innodb_data_writes';
7
SHOW STATUS LIKE 'Innodb_data_written';
8
SHOW STATUS LIKE 'Innodb_fsyncs';
9

10
-- 计算脏页比例
11
SELECT
12
    variable_value + 0 AS dirty_pages,
13
    (SELECT variable_value + 0
14
     FROM performance_schema.global_status
15
     WHERE variable_name = 'Innodb_buffer_pool_pages_total') AS total_pages,
16
    (variable_value + 0) / (SELECT variable_value + 0
17
     FROM performance_schema.global_status
18
     WHERE variable_name = 'Innodb_buffer_pool_pages_total') * 100 AS dirty_pct
19
FROM performance_schema.global_status
20
WHERE variable_name = 'Innodb_buffer_pool_pages_dirty';