1
# HDD 延迟计算示例
2
def hdd_access_time(rpm=7200, seek_distance="average", data_size=4096):
3
    """计算 HDD 访问延迟"""
4
    # 寻道延迟
5
    seek_times = {
6
        "track_to_track": 0.5,   # ms, 相邻磁道
7
        "average": 4.16,          # ms, 平均寻道
8
        "full_stroke": 10.0,     # ms, 全程寻道
9
    }
10
    t_seek = seek_times[seek_distance]
11

12
    # 旋转延迟（平均半圈）
13
    t_rotation = 0.5 * (60 / rpm) * 1000  # ms
14

15
    # 传输延迟
16
    transfer_rate = 200  # MB/s (外圈)
17
    t_transfer = (data_size / (1024 * 1024)) / transfer_rate * 1000  # ms
18

19
    total = t_seek + t_rotation + t_transfer
20

21
    print(f"寻道延迟: {t_seek:.2f} ms")
22
    print(f"旋转延迟: {t_rotation:.2f} ms")
23
    print(f"传输延迟: {t_transfer:.4f} ms")
24
    print(f"总延迟:   {total:.2f} ms")
25
    print(f"寻道占比: {t_seek/total*100:.1f}%")
26
    print(f"旋转占比: {t_rotation/total*100:.1f}%")
27

28
hdd_access_time()
29
# 寻道延迟: 4.16 ms
30
# 旋转延迟: 4.17 ms
31
# 传输延迟: 0.0195 ms
32
# 总延迟:   8.35 ms
33
# 寻道占比: 49.8%
34
# 旋转占比: 49.9%

1
# 使用 fio 测试 HDD 性能
2
# 顺序读
3
fio --name=seq-read --rw=read --bs=1M --size=1G --numjobs=1 --runtime=60
4

5
# 随机读
6
fio --name=rand-read --rw=randread --bs=4K --size=1G --numjobs=1 --runtime=60 \
7
    --iodepth=1 --ioengine=libaio
8

9
# 结果示例（7200 RPM HDD）：
10
# 顺序读: ~180 MB/s
11
# 随机读: ~0.4 MB/s (~100 IOPS)
12
# 差距: 450x

1
# SSD 寿命计算
2
def ssd_endurance(capacity_tb=1, nand_type="TLC", dwpd=1):
3
    """计算 SSD 寿命"""
4
    pe_cycles = {"SLC": 100000, "MLC": 3000, "TLC": 1000, "QLC": 200}
5

6
    # 总写入量 = 容量 × P/E 次数
7
    total_write_tb = capacity_tb * pe_cycles[nand_type]
8

9
    # 每日写入量（DWPD = Drive Writes Per Day）
10
    daily_write_tb = capacity_tb * dwpd
11

12
    # 寿命（天）
13
    lifetime_days = total_write_tb / daily_write_tb
14
    lifetime_years = lifetime_days / 365
15

16
    print(f"NAND 类型: {nand_type}")
17
    print(f"容量: {capacity_tb} TB")
18
    print(f"P/E 次数: {pe_cycles[nand_type]:,}")
19
    print(f"总写入量: {total_write_tb:,.0f} TB")
20
    print(f"每日写入: {daily_write_tb} TB (DWPD={dwpd})")
21
    print(f"预计寿命: {lifetime_years:.1f} 年")
22

23
ssd_endurance(1, "TLC", 1)
24
# NAND 类型: TLC
25
# 容量: 1 TB
26
# P/E 次数: 1,000
27
# 总写入量: 1,000 TB
28
# 每日写入: 1 TB (DWPD=1)
29
# 预计寿命: 2.7 年

1
// FTL 核心数据结构（简化）
2
struct FTL {
3
    // 逻辑到物理的映射表
4
    // LBA (Logical Block Address) → PPA (Physical Page Address)
5
    ppa_t *mapping_table;    // 通常存在 DRAM 中
6

7
    // 块信息表
8
    struct BlockInfo {
9
        int     valid_page_count;   // 有效页数
10
        int     erase_count;        // 擦除次数（磨损均衡）
11
        block_state_t state;        // FREE/IN_USE/GC
12
    } *block_info;
13

14
    // 垃圾回收器
15
    struct GC {
16
        int     threshold;          // 触发 GC 的空闲块阈值
17
        gc_policy_t policy;         // GC 策略（贪心/成本效益）
18
    };
19
};
20

21
// 写入流程
22
void ftl_write(FTL *ftl, lba_t lba, void *data, int size) {
23
    // 1. 分配新的物理页（Out-of-place Update）
24
    ppa_t new_ppa = allocate_page(ftl);
25

26
    // 2. 写入数据到新物理页
27
    nand_write(new_ppa, data, size);
28

29
    // 3. 更新映射表
30
    ppa_t old_ppa = ftl->mapping_table[lba];
31
    ftl->mapping_table[lba] = new_ppa;
32

33
    // 4. 标记旧页为无效
34
    mark_page_invalid(ftl, old_ppa);
35

36
    // 5. 检查是否需要 GC
37
    if (free_blocks(ftl) < ftl->gc.threshold) {
38
        garbage_collect(ftl);
39
    }
40
}

1
# SSD 垃圾回收策略
2
class GarbageCollector:
3
    def select_victim_block(self, blocks):
4
        """选择回收哪个块"""
5
        if self.policy == "greedy":
6
            # 贪心策略：选择无效页最多的块
7
            return max(blocks, key=lambda b: b.invalid_pages / b.total_pages)
8

9
        elif self.policy == "cost_benefit":
10
            # 成本效益策略：考虑块的使用频率和年龄
11
            # cost_benefit = (1 - u) / (1 + u) * age
12
            # u = 有效页比例, age = 距上次擦除的时间
13
            return max(blocks, key=lambda b:
14
                (1 - b.valid_ratio) / (1 + b.valid_ratio) * b.age)
15

16
        elif self.policy == "d_choice":
17
            # d-choice：随机选 d 个块，选最优的
18
            candidates = random.sample(blocks, min(self.d, len(blocks)))
19
            return max(candidates, key=lambda b: b.invalid_pages)
20

21
    def gc_process(self, victim_block):
22
        """垃圾回收流程"""
23
        # 1. 读取有效页
24
        valid_pages = [p for p in victim_block.pages if p.is_valid]
25

26
        # 2. 将有效页搬移到新块
27
        for page in valid_pages:
28
            new_ppa = self.allocate_page()
29
            self.nand_write(new_ppa, page.data)
30
            self.update_mapping(page.lba, new_ppa)
31

32
        # 3. 擦除旧块
33
        self.nand_erase(victim_block)
34

35
        # 4. 更新统计
36
        self.write_amplification += len(valid_pages)

1
# 查看 NVMe 设备信息
2
nvme list
3

4
# 查看 NVMe 健康状态
5
nvme smart-log /dev/nvme0
6

7
# 输出示例：
8
# Critical Warning                    : 0
9
# Temperature                         : 38°C
10
# Available Spare                     : 100%
11
# Percentage Used                     : 2%        # 已用寿命百分比
12
# Data Units Read                     : 12,345,678
13
# Data Units Written                  : 23,456,789
14
# Host Read Commands                  : 456,789,012
15
# Host Write Commands                 : 345,678,901
16
# Controller Busy Time                : 1,234 hours
17
# Power Cycles                        : 567
18
# Power On Hours                      : 8,760
19
# Unsafe Shutdowns                    : 12
20
# Media and Data Integrity Errors     : 0

1
# 手动执行 TRIM
2
fstrim -v /mnt/ssd
3

4
# 查看是否支持 TRIM
5
lsblk -D
6
# DISC-ALN DISC-GRAN DISC-MAX DISC-ZERO
7
# 0        512B      2G       0
8

9
# 持续 TRIM（挂载选项）
10
mount -o discard /dev/nvme0n1p1 /mnt/ssd
11
# 注意：持续 TRIM 可能影响性能，建议使用定期 fstrim
12

13
# 在 /etc/fstab 中配置
14
# /dev/nvme0n1p1 /mnt/ssd ext4 defaults,noatime,discard 0 2

1
# 存储选择决策树
2
def choose_storage(workload):
3
    if workload.type == "OLTP":
4
        if workload.iops_requirement > 10000:
5
            return "NVMe SSD (必选)"
6
        elif workload.iops_requirement > 1000:
7
            return "SATA SSD (推荐) 或 NVMe SSD"
8
        else:
9
            return "SATA SSD (够用)"
10

11
    elif workload.type == "OLAP":
12
        if workload.data_size > "10TB":
13
            return "HDD + SSD 缓存 (成本优先)"
14
        else:
15
            return "NVMe SSD (性能优先)"
16

17
    elif workload.type == "Archive":
18
        return "HDD 或对象存储 (成本优先)"
19

20
    elif workload.type == "Log":
21
        return "NVMe SSD (低延迟写入)"

1
# 查看块设备信息
2
lsblk -o NAME,SIZE,TYPE,ROTA,TRAN,MODEL
3
# ROTA=0 → SSD, ROTA=1 → HDD
4

5
# 查看详细设备信息
6
smartctl -a /dev/nvme0n1
7
smartctl -a /dev/sda
8

9
# 查看 SSD 寿命
10
nvme smart-log /dev/nvme0n1 | grep "Percentage Used"

1
# 4K 随机读测试（SSD）
2
fio --name=rand-read-4k --rw=randread --bs=4k \
3
    --size=10G --numjobs=4 --iodepth=32 \
4
    --ioengine=libaio --direct=1 --runtime=60
5

6
# 4K 随机写测试（SSD）
7
fio --name=rand-write-4k --rw=randwrite --bs=4k \
8
    --size=10G --numjobs=4 --iodepth=32 \
9
    --ioengine=libaio --direct=1 --runtime=60
10

11
# 顺序读写测试
12
fio --name=seq-read --rw=read --bs=128k \
13
    --size=10G --numjobs=1 --ioengine=libaio --direct=1
14

15
# 混合读写测试（70% 读 / 30% 写）
16
fio --name=mixed --rw=randrw --rwmixread=70 --bs=4k \
17
    --size=10G --numjobs=4 --iodepth=32 \
18
    --ioengine=libaio --direct=1 --runtime=60

1
# 查看 SSD 写入统计
2
nvme smart-log /dev/nvme0n1 | grep -E "Data Units|Host"
3

4
# 计算 WA
5
# WA = Data Units Written / Host Write Commands * (512 / 页大小)
6
# 例如：
7
# Data Units Written: 1,000,000 (× 512B = 512GB)
8
# Host Write Commands: 50,000,000 × 4KB = 200GB
9
# WA = 512GB / 200GB = 2.56x

1
-- 在 HDD 和 SSD 上分别执行
2
-- 插入 10 万条记录
3
INSERT INTO storage_test (data, payload)
4
SELECT CONCAT('record_', n), REPEAT('x', 1000)
5
FROM (
6
    WITH RECURSIVE nums AS (
7
        SELECT 1 AS n UNION ALL SELECT n+1 FROM nums WHERE n < 100000
8
    ) SELECT n FROM nums
9
) t;
10

11
-- 随机点查
12
SELECT * FROM storage_test WHERE id = 50000;
13

14
-- 范围扫描
15
SELECT COUNT(*) FROM storage_test WHERE id BETWEEN 40000 AND 60000;