1
# RAID 5 校验计算
2
def raid5_parity(data_blocks):
3
    """计算 RAID 5 校验块"""
4
    parity = 0
5
    for block in data_blocks:
6
        parity ^= block  # XOR 运算
7
    return parity
8

9
# 重建：如果 Disk 1 故障
10
# D1 = P0 ⊕ D0 = (D0 ⊕ D1) ⊕ D0 = D1
11
def raid5_reconstruct(surviving_blocks, parity_block):
12
    """从校验块重建丢失数据"""
13
    result = parity_block
14
    for block in surviving_blocks:
15
        result ^= block
16
    return result

1
# RAID 6 Q 校验（基于 Reed-Solomon）
2
# P = D0 ⊕ D1 ⊕ D2 ⊕ ... ⊕ Dn-1  （XOR）
3
# Q = g^0*D0 ⊕ g^1*D1 ⊕ g^2*D2 ⊕ ... ⊕ g^(n-1)*Dn-1  （伽罗瓦域乘法）
4

5
# 重建 2 盘故障：
6
# 解线性方程组
7
# [1, 1, 1, ...] × [D0, D1, D2, ...]^T = P
8
# [g^0, g^1, g^2, ...] × [D0, D1, D2, ...]^T = Q
9

10
def raid6_reconstruct(surviving_data, p_block, q_block,
11
                       failed_indices):
12
    """重建 2 个丢失的数据块"""
13
    # 在伽罗瓦域 GF(2^8) 上解线性方程组
14
    # 使用矩阵运算
15
    n = len(surviving_data) + len(failed_indices)
16

17
    # 构建系数矩阵
18
    matrix = build_rs_matrix(n)
19

20
    # 求解
21
    failed_data = solve_galoian_system(matrix, surviving_data,
22
                                         p_block, q_block, failed_indices)
23
    return failed_data

1
# Reed-Solomon 编码（简化）
2
import numpy as np
3

4
def reed_solomon_encode(data_blocks, k, m):
5
    """Reed-Solomon 编码"""
6
    # 构建编码矩阵（Vandermonde 矩阵）
7
    # 在伽罗瓦域 GF(2^8) 上运算
8
    encode_matrix = build_vandermonde_matrix(k + m, k)
9

10
    # 编码：parity = encode_matrix × data_blocks
11
    parity_blocks = np.dot(encode_matrix[k:], data_blocks)
12

13
    return parity_blocks
14

15
def reed_solomon_decode(surviving_blocks, surviving_indices,
16
                         k, m):
17
    """Reed-Solomon 解码"""
18
    # 从幸存块构建解码矩阵
19
    decode_matrix = build_decode_matrix(surviving_indices, k)
20

21
    # 解码：original = decode_matrix × surviving_blocks
22
    original_blocks = np.dot(decode_matrix, surviving_blocks)
23

24
    return original_blocks
25

26
# 常见配置
27
ec_configs = {
28
    "Ceph": {"k": 8, "m": 3, "utilization": "73%", "fault_tolerance": 3},
29
    "MinIO": {"k": 8, "m": 4, "utilization": "67%", "fault_tolerance": 4},
30
    "HDFS": {"k": 6, "m": 3, "utilization": "67%", "fault_tolerance": 3},
31
    "S3": {"k": 12, "m": 4, "utilization": "75%", "fault_tolerance": 4},
32
}

1
# 数据放置策略
2
def place_data_blocks(k, m, fault_domains):
3
    """将数据块和校验块分散到不同故障域"""
4
    total_blocks = k + m
5

6
    # 确保同一故障域内不超过 1 个块
7
    # 这样即使整个故障域故障，也只丢失 1 个块
8
    if len(fault_domains) < total_blocks:
9
        raise ValueError("故障域数量不足")
10

11
    placement = {}
12
    for i, block in enumerate(range(total_blocks)):
13
        # 选择故障域
14
        domain = fault_domains[i % len(fault_domains)]
15
        placement[block] = domain
16

17
    return placement
18

19
# Ceph CRUSH 算法就是这种策略的复杂版本
20
# 它考虑了多层故障域：host → rack → row → room → DC

1
# RAID/纠删码重建时间估算
2
def estimate_rebuild_time(disk_size_tb, disk_speed_mbps,
3
                           rebuild_method, k=8):
4
    """估算重建时间"""
5
    disk_size_mb = disk_size_tb * 1024 * 1024
6

7
    if rebuild_method == "raid5":
8
        # 从 1 个校验块重建
9
        rebuild_speed = disk_speed_mbps
10
        time_hours = disk_size_mb / rebuild_speed / 3600
11

12
    elif rebuild_method == "raid6":
13
        # 从 2 个校验块重建
14
        rebuild_speed = disk_speed_mbps
15
        time_hours = disk_size_mb / rebuild_speed / 3600
16

17
    elif rebuild_method == "ec_8_4":
18
        # 纠删码：需要从 k 个块重建
19
        # 网络流量 = k × 丢失块大小
20
        rebuild_speed = disk_speed_mbps * k  # 需要读取 k 个块
21
        time_hours = disk_size_mb / rebuild_speed / 3600
22

23
    print(f"磁盘大小: {disk_size_tb} TB")
24
    print(f"重建方法: {rebuild_method}")
25
    print(f"预计时间: {time_hours:.1f} 小时")
26
    return time_hours
27

28
estimate_rebuild_time(20, 200, "raid5")
29
# 磁盘大小: 20 TB
30
# 重建方法: raid5
31
# 预计时间: 27.8 小时
32

33
estimate_rebuild_time(20, 200, "ec_8_4", 8)
34
# 磁盘大小: 20 TB
35
# 重建方法: ec_8_4
36
# 预计时间: 3.5 小时（并行读取 8 个块）

1
# 重建期间 I/O 争用分析
2
def rebuild_io_contention(disk_size_tb, disk_speed_mbps, rebuild_priority=0.3):
3
    disk_size_mb = disk_size_tb * 1024 * 1024
4

5
    # 重建占用磁盘带宽的比例
6
    rebuild_bandwidth = disk_speed_mbps * rebuild_priority
7
    # 剩余带宽给业务 I/O
8
    business_bandwidth = disk_speed_mbps * (1 - rebuild_priority)
9

10
    # 重建时间
11
    rebuild_hours = disk_size_mb / rebuild_bandwidth / 3600
12

13
    # 业务 I/O 延迟影响
14
    # 重建产生大量顺序读，与业务随机读争用磁盘
15
    # HDD 上延迟可能增加 3-10 倍
16
    latency_multiplier = 3 if disk_speed_mbps < 300 else 1.5
17

18
    print(f"重建带宽占比: {rebuild_priority*100:.0f}%")
19
    print(f"重建时间: {rebuild_hours:.1f} 小时")
20
    print(f"业务延迟倍增: {latency_multiplier}x")
21

22
rebuild_io_contention(20, 200, 0.3)
23
# 重建带宽占比: 30%
24
# 重建时间: 92.6 小时
25
# 业务延迟倍增: 3x

1
# Reed-Solomon 编码原理（简化）
2
# 步骤 1: 构建编码矩阵（Vandermonde 矩阵）
3
# [1  1   1   1  ]   [D0]   [D0 + D1 + D2 + D3]
4
# [1  g   g^2 g^3] x [D1] = [D0 + g*D1 + g^2*D2 + g^3*D3]
5
# [1  g^2 g^4 g^6]   [D2]   [D0 + g^2*D1 + g^4*D2 + g^6*D3]
6
#                    [D3]
7

8
# 步骤 2: 前 k 行为单位矩阵（数据块不变），后 m 行为校验块
9
# [I ]   [D0]   [D0]       (数据块)
10
# [  ] x [D1] = [D1]       (数据块)
11
# [V ]   [D2]   [P0]       (校验块)
12
#        [D3]   [P1]       (校验块)
13

14
# 步骤 3: 解码——从任意 k 个幸存块构建解码矩阵
15
# 取幸存行组成新矩阵 M'，求逆 M'^-1
16
# original = M'^-1 x surviving_blocks

1
# Ceph 纠删码配置
2
# 创建纠删码 Profile
3
ceph osd erasure-code-profile set my-ec-profile     plugin=jerasure     k=8 m=3     technique=reed_sol_van     crush-failure-domain=host
4

5
# 创建纠删码存储池
6
ceph osd pool create my-ec-pool 128 128 erasure my-ec-profile
7

8
# 覆盖写入支持（需要显式开启）
9
ceph osd pool set my-ec-pool allow_ec_overwrites true
10
# 注意：开启后不保证原子性覆盖写入，仅适合对象/文件存储

1
# 使用 mdadm 创建 RAID
2
# RAID 1（镜像）
3
mdadm --create /dev/md0 --level=1 --raid-devices=2 /dev/sda1 /dev/sdb1
4

5
# RAID 5（条带+校验）
6
mdadm --create /dev/md1 --level=5 --raid-devices=4 \
7
    /dev/sda1 /dev/sdb1 /dev/sdc1 /dev/sdd1
8

9
# RAID 10（镜像+条带）
10
mdadm --create /dev/md2 --level=10 --raid-devices=4 \
11
    /dev/sda1 /dev/sdb1 /dev/sdc1 /dev/sdd1
12

13
# 查看 RAID 状态
14
cat /proc/mdstat
15
mdadm --detail /dev/md0
16

17
# 重建进度
18
# Personalities : [raid1] [raid6] [raid5] [raid10]
19
# md0 : active raid1 sda1[0] sdb1[1]
20
#       2095104 blocks super 1.2 [2/2] [UU]
21
# md1 : active raid5 sda1[0] sdb1[1] sdc1[2] sdd1[3]
22
#       6286528 blocks super 1.2 level 5, 64k chunk, algorithm 2 [4/4] [UUUU]

1
# RAID 性能基准测试
2
# 顺序读
3
fio --name=raid-seq-read --directory=/mnt/raid --rw=read --bs=1M \
4
    --size=10G --numjobs=4 --ioengine=libaio --direct=1
5

6
# 随机写
7
fio --name=raid-rand-write --directory=/mnt/raid --rw=randwrite --bs=4k \
8
    --size=10G --numjobs=4 --iodepth=32 --ioengine=libaio --direct=1
9

10
# RAID 5 写惩罚：每次写入需要 4 次 I/O
11
# 1. 读取旧数据块
12
# 2. 读取旧校验块
13
# 3. 写入新数据块
14
# 4. 写入新校验块

1
# RAID 写惩罚计算
2
def raid_write_penalty():
3
    """计算不同 RAID 级别的写惩罚"""
4
    penalties = {
5
        "RAID 0": {"full_write": 1, "random_write": 1},
6
        "RAID 1": {"full_write": 2, "random_write": 2},
7
        "RAID 5": {"full_write": 1, "random_write": 4},
8
        "RAID 6": {"full_write": 1, "random_write": 6},
9
        "RAID 10": {"full_write": 2, "random_write": 2},
10
    }
11

12
    for raid, penalty in penalties.items():
13
        print(f"{raid:8s}: 全量写入={penalty['full_write']}x, "
14
              f"随机写入={penalty['random_write']}x")
15

16
raid_write_penalty()
17
# RAID 0:   全量写入=1x, 随机写入=1x
18
# RAID 1:   全量写入=2x, 随机写入=2x
19
# RAID 5:   全量写入=1x, 随机写入=4x
20
# RAID 6:   全量写入=1x, 随机写入=6x
21
# RAID 10:  全量写入=2x, 随机写入=2x