1
// InnoDB B+ 树点查流程
2
byte *btree_search(dict_index_t *index, dtuple_t *key) {
3
    // 1. 从根页面开始
4
    page_id_t page_id = index->root_page;
5

6
    // 2. 逐层向下查找
7
    while (true) {
8
        // 2a. 在 Buffer Pool 中查找页面
9
        page_t *page = buf_pool_get(page_id);
10

11
        if (page == NULL) {
12
            // 2b. Buffer Pool 未命中，从磁盘读取
13
            page = buf_read_page(page_id);
14
        }
15

16
        // 2c. 在页面内二分查找
17
        int slot = page_binary_search(page, key);
18

19
        if (page->is_leaf) {
20
            // 2d. 叶子页面：返回数据
21
            return page_get_record(page, slot);
22
        }
23

24
        // 2e. 内部页面：获取子节点页面 ID
25
        page_id = page_get_child(page, slot);
26
    }
27
}

1
// B+ 树范围扫描
2
void btree_range_scan(dict_index_t *index,
3
                       dtuple_t *start_key, dtuple_t *end_key,
4
                       scan_callback_t callback) {
5
    // 1. 定位起始 Key
6
    page_t *page = btree_find_leaf(index, start_key);
7
    int slot = page_find_slot(page, start_key);
8

9
    // 2. 沿叶子链表扫描
10
    while (page != NULL) {
11
        for (int i = slot; i < page->n_records; i++) {
12
            record_t *rec = page->records[i];
13

14
            // 检查是否超出范围
15
            if (compare(rec->key, end_key) > 0) {
16
                return;  // 扫描结束
17
            }
18

19
            // 回调处理
20
            callback(rec);
21
        }
22

23
        // 移到下一个叶子页面
24
        page = buf_pool_get(page->next_page);
25
        slot = 0;
26
    }
27
}

1
// RocksDB 点查流程
2
Status rocksdb_get(DB *db, const Slice &key, string *value) {
3
    // 1. 查找 MemTable
4
    if (db->memtable->Get(key, value)) {
5
        return Status::OK();  // 命中
6
    }
7

8
    // 2. 查找 Immutable MemTable
9
    if (db->immutable && db->immutable->Get(key, value)) {
10
        return Status::OK();  // 命中
11
    }
12

13
    // 3. 查找 SSTable（从 L0 到 Ln）
14
    for (int level = 0; level < db->num_levels; level++) {
15
        // 3a. 检查 Bloom Filter
16
        if (!bloom_filter_may_contain(db->levels[level], key)) {
17
            continue;  // 跳过此层级
18
        }
19

20
        // 3b. 在索引中查找目标 Data Block
21
        BlockHandle handle;
22
        if (!index_find(db->levels[level], key, &handle)) {
23
            continue;  // Key 不在此层级范围内
24
        }
25

26
        // 3c. 在 Block Cache 中查找
27
        Block *block = block_cache_lookup(handle);
28
        if (block == NULL) {
29
            // 3d. 从磁盘读取 Data Block
30
            block = read_data_block(handle);
31
            block_cache_insert(handle, block);
32
        }
33

34
        // 3e. 在 Data Block 中查找 Key
35
        if (block_get(block, key, value)) {
36
            return Status::OK();  // 命中
37
        }
38
    }
39

40
    return Status::NotFound("Key not found");
41
}

1
# LSM 树读放大分析
2
def lsm_read_amplification(n_levels=7, l0_files=4):
3
    """分析 LSM 树的读放大"""
4
    # 最坏情况：检查所有层级
5
    # L0: 检查 l0_files 个 SSTable
6
    # L1+: 每层检查 1 个 SSTable（键范围不重叠）
7

8
    # 无 Bloom Filter
9
    worst_case = l0_files + (n_levels - 1)
10
    print(f"最坏情况（无 Bloom Filter）: {worst_case} 次 SSTable 查找")
11

12
    # 有 Bloom Filter（假阳性率 1%）
13
    # L0: 每个文件都需检查（键范围重叠）
14
    # L1+: Bloom Filter 过滤 99% 的无效查找
15
    bloom_fp_rate = 0.01
16
    l1_plus_checks = (n_levels - 1) * bloom_fp_rate
17
    typical_case = l0_files + l1_plus_checks
18
    print(f"典型情况（有 Bloom Filter）: {typical_case:.2f} 次 SSTable 查找")
19

20
    # 每次 SSTable 查找需要：
21
    # 1. 读取索引块（通常在缓存中）
22
    # 2. 读取数据块（可能需要磁盘 I/O）
23
    # 所以典型情况约 1–2 次磁盘 I/O
24

25
lsm_read_amplification()
26
# 最坏情况（无 Bloom Filter）: 10 次 SSTable 查找
27
# 典型情况（有 Bloom Filter）: 4.06 次 SSTable 查找

1
# RocksDB Bloom Filter 配置
2
bloom_configs = {
3
    "读密集": {
4
        "bits_per_key": 16,     # 假阳性率 ~0.05%
5
        "block_based": True,    # 分区 Bloom
6
        "cache_bloom": True,    # 缓存 Bloom 到 Block Cache
7
    },
8
    "均衡": {
9
        "bits_per_key": 10,     # 假阳性率 ~0.82%
10
        "block_based": True,
11
        "cache_bloom": True,
12
    },
13
    "写密集": {
14
        "bits_per_key": 6,      # 假阳性率 ~5%
15
        "block_based": False,   # 全局 Bloom
16
        "cache_bloom": False,
17
    },
18
}
19

20
for name, config in bloom_configs.items():
21
    print(f"{name:8s}: bits/key={config['bits_per_key']}, "
22
          f"block_based={config['block_based']}")

1
# Block Cache 大小建议
2
def recommend_block_cache(total_memory_gb, workload_type):
3
    """推荐 Block Cache 大小"""
4
    if workload_type == "read_intensive":
5
        cache_ratio = 0.5  # 50% 内存给 Cache
6
    elif workload_type == "balanced":
7
        cache_ratio = 0.3  # 30%
8
    else:  # write_intensive
9
        cache_ratio = 0.15  # 15%
10

11
    cache_size = total_memory_gb * cache_ratio
12
    print(f"总内存: {total_memory_gb} GB")
13
    print(f"工作负载: {workload_type}")
14
    print(f"推荐 Block Cache: {cache_size:.1f} GB ({cache_ratio*100:.0f}%)")
15
    return cache_size
16

17
recommend_block_cache(64, "read_intensive")
18
# 总内存: 64 GB
19
# 工作负载: read_intensive
20
# 推荐 Block Cache: 32.0 GB (50%)

1
// InnoDB 自适应预读算法（简化）
2
void buf_read_ahead(page_id_t page_id) {
3
    // 1. 检测访问模式
4
    int recent_accesses = count_recent_accesses(page_id, WINDOW_SIZE);
5

6
    if (is_sequential_access(page_id)) {
7
        // 顺序访问：预读后续页面
8
        int prefetch_pages = min(READ_AHEAD_AREA,
9
                                  remaining_pages_in_extent(page_id));
10
        for (int i = 1; i <= prefetch_pages; i++) {
11
            buf_read_page_async(page_id + i);
12
        }
13
    } else if (recent_accesses > RANDOM_READ_AHEAD_THRESHOLD) {
14
        // 随机访问但频率高：预读同一 Extent 的页面
15
        for (int i = 0; i < PAGES_PER_EXTENT; i++) {
16
            page_id_t pid = extent_first_page(page_id) + i;
17
            if (!buf_pool_contains(pid)) {
18
                buf_read_page_async(pid);
19
            }
20
        }
21
    }
22
}

1
-- InnoDB 读取相关配置
2
-- Buffer Pool 大小（最重要的参数）
3
SET GLOBAL innodb_buffer_pool_size = 42949672960;  -- 40GB
4

5
-- 预读配置
6
SET GLOBAL innodb_read_ahead_threshold = 56;  -- 默认值
7
-- 设为 0 可关闭预读（OLTP 场景可能有益）
8

9
-- 自适应哈希索引
10
SET GLOBAL innodb_adaptive_hash_index = 1;  -- 开启
11

12
-- 随机预读
13
SET GLOBAL innodb_random_read_ahead = 0;  -- 通常关闭

1
# RocksDB 读取相关配置
2
# Block Cache 大小
3
block_cache_size = 34359738368  # 32GB
4

5
# Bloom Filter
6
bloom_bits_per_key = 10  # 10 bits/key
7

8
# 预取大小
9
readahead_size = 0  # 关闭预读（点查场景）
10

11
# 索引缓存
12
cache_index_and_filter_blocks = true  # 缓存索引和 Bloom
13

14
# Pin 索引和 Bloom
15
pin_l0_filter_and_index_blocks_in_cache = true  # L0 的索引常驻内存

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

17
-- 目标：Buffer Pool 命中率 > 99%

1
# RocksDB 统计信息
2
# Block Cache 命中率
3
# block.cache.hit / (block.cache.hit + block.cache.miss)
4

5
# Bloom Filter 效率
6
# bloom.filter.useful / bloom.filter.checked
7

8
# 典型输出：
9
# Block Cache hit ratio: 95.2%
10
# Bloom Filter useful: 87.3%
11
# Get micros avg: 12.5

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

5
# 使用 bcc 分析读取延迟
6
/usr/share/bcc/tools/biolatency -p $(pidof mysqld) 1 5
7

8
# 使用 MySQL 慢查询日志
9
# 开启慢查询日志
10
SET GLOBAL slow_query_log = ON;
11
SET GLOBAL long_query_time = 0.01;  -- 10ms