【学习笔记】详细图解RAID设计（操作系统导论38章作业）

通过完成操作系统导论38章作业来理解廉价冗余磁盘阵列RAID的四种设计的块位置计算，其中详细图解RAID-5中的奇偶校验块跨驱动器旋转的左对称、左不对称方式。

38.1

Use the simulator to perform some basic RAID mapping tests. Run with different levels (0, 1, 4, 5) and see if you can figure out the mappings of a set of requests. For RAID-5, see if you can figure out the difference between left-symmetric and left-asymmetric layouts. Use some different random seeds to generate different problems than above.

RAID-0

运行指令：python2 raid.py -n 5 -L 0 -R 30

采用RAID-0，只是简单的条带化。所以磁盘序号=地址%磁盘数，偏移量=地址/磁盘数，磁盘数是4，所以结果如下：

地址	磁盘序号=地址%4	偏移量=地址/4
25	1	6
12	0	3
15	3	3
23	3	5
14	2	3

-c验证：

RAID-1

python2 raid.py -n 5 -L 1 -R 30


RAID-1每个块都有镜像对，所以磁盘序号=地址*2 % 磁盘数（/ +=1），偏移量=地址*2 / 磁盘数，磁盘数是4.

地址	磁盘序号=地址*2%4 (/+1)	偏移量=地址*2/4
25	2/3	12
12	0/1	6
15	2/3	7
23	2/3	11
14	0/1	7

-c验证：

RAID-4

python2 raid.py -n 5 -L 4 -R 30


如图，RAID-4最后一个磁盘是奇偶校验，所以磁盘序号=地址 % (磁盘数-1)，偏移量=地址 / (磁盘数-1)，磁盘数是4 。

地址	磁盘序号=地址%3	偏移量=地址/3
25	1	8
12	0	3
15	3	3
23	3	5
14	2	3

-c验证：

RAID-5

RAID-5采用了奇偶校验块跨驱动器旋转，如下图：

但是旋转的方式可能会不一样。

左对称

设置磁盘数位5 -D 5，样例数40 -n 40，顺序读写-W seq，左对称 -5 LS，指令是:python2 raid.py -n 40 -L 5 -D 5 -W seq -5 LS -c

位置如下面表格：

磁盘0	磁盘1	磁盘2	磁盘3	磁盘4
0	1	2	3	P0
5	6	7	P1	4
10	11	P2	8	9
15	P3	12	13	14
P4	16	17	18	19
20	21	22	23	P5
25	26	27	P6	24
30	31	P7	28	29
35	P8	32	33	34

注意，方向如下：

左不对称

然后看到左不对称 -5 LA，python2 raid.py -n 40 -L 5 -D 5 -W seq -5 LA -c

位置如下：

磁盘0	磁盘1	磁盘2	磁盘3	磁盘4
0	1	2	3	P0
4	5	6	P1	7
8	9	P2	10	11
12	P3	13	14	15
P4	16	17	18	19
20	21	22	23	P5
24	25	26	P6	27
28	29	P7	30	31
32	P8	33	34	35

方向如下：

我太南了 查阅资料发现：左/右指的是校验信息如何分布，而对称/非对称指的是数据如何分布。

RAID5 的奇偶校验信息是在磁盘上交叉存放的。有四种分布方式： 1、向左对称 2、向 左非对称 3、向右对称 4、向右非对称。 基本上，左/右指的是校验信息如何分布，而对称/非对称指的是数据如何分布。"左"算 法中，校验从最后一个磁盘开始，每一个条带将校验向靠近第一个磁盘的方向移动一个磁盘的位置（必要时重绕）。而"右"算法则相反，其校验从第一个磁盘开始，每一个条 带将校验向靠近最后一个磁盘的方向移动一个磁盘的位置（必要时重绕）。"非对称"算 法将给定条带的数据块按简单的顺序方式放置，必要时跳过条带，并且总是从第一个磁盘上的第一个条带的数据块开始。与之不同的是，"对称"算法并不是将条带的第一个块放在第一个磁盘上，而是连续将数据块按顺序磁盘序列的方式分布，只是在必要时重绕回第一个磁盘。因此对称算法对于大量顺序读操作有更好的性能。

说白了就是下面的草图那样（红线是奇偶校验位，黄线是地址编号）：我画得真好

38.2

Do the same as the first problem, but this time vary the chunk size with -C. How does chunk size change the mappings?

就是说改变大块的大小，看看有什么不一样。

那就把大块的大小由原来的4096乘以2变成8192。

RAID-0

python2 raid.py -n 20 -L 0 -D 4 -W seq -C 8192 -c

跟书上图一样了：

RAID-1

python2 raid.py -n 20 -L 1 -D 4 -W seq -C 8192 -c

如表格：

磁盘0	磁盘1	磁盘2	磁盘3
0	0	2	2
1	1	3	3
4	4	6	6
5	5	7	7
8	8	10	10
9	9	11	11

RAID-4

python2 raid.py -n 20 -L 4 -D 4 -W seq -C 8192 -c

位置如下：

磁盘0	磁盘1	磁盘2	磁盘3
0	2	4	P
1	3	5	P
6	8	10	P
7	9	11	P
12	14	15	P
13	15	16	P

RAID-5

python2 raid.py -n 20 -L 5 -D 4 -W seq -C 8192 -c

位置如下：

磁盘0	磁盘1	磁盘2	磁盘3
0	2	4	P
1	3	5	P
8	10	P	6
9	11	P	7
16	P	12	14
17	P	13	15
P	18	20	22
P	19	21	23

方向如下：

奇偶校验大块的旋转方式跟块大小无关，看成一个整体就行了。

38.3

Do the same as above, but use the -r flag to reverse the nature of each problem.

就是说用-r标志，使得问题反转，之前是告诉逻辑地址，求物理地址；现在是告诉物理地址，求逻辑地址。

例如这样：python2 raid.py -n 10 -L 1 -D 4 -R 30 -r

整个位置布局我都分析出来了，所以计算肯定没问题了，跳过吧。

38.4

Now use the reverse flag but increase the size of each request with the -S flag. Try specifying sizes of 8k, 12k, and 16k, while varying the RAID level. What happens to the underlying I/O pattern when the size of the request increases? Make sure to try this with the sequential workload too (-W sequential); for what request sizes are RAID-4 and RAID-5 much more I/O efficient?

用-S改变请求的大小，看看底层I/O模式会发生什么。

8k

先是8k的写请求，大块的大小是4k，所以会是连续写两个大块，相当于对地址和地址+1的请求。

RAID-0：python2 raid.py -R 30 -n 5 -L 0 -S 8k -w 100 -c （-w 100是写请求）

显然，每次直接写入两个块，2次写操作。

RAID-1：python2 raid.py -R 30 -n 5 -L 1 -S 8k -w 100 -c

可以看出，因为有镜像，每次写入两个块，以及它的镜像块，所以会有4次写操作。

RAID-4:python2 raid.py -R 30 -n 5 -L 4 -S 8k -w 100 -c

正常如果请求的大小跟块大小一样，应该要次先读地址对应的块，再读奇偶校验块，判断是否需要改变，然后再写入地址对应的块和校验块即可。但是请求大小为8k的话，其实是写入地址和地址+1的块，若两个块不连续，则需要两次上述的操作，需要8个I/O操作；若这两个块是连续的（偏移量一样），奇妙的事情发生了，例如第一个例子，要写25（还有26），如下图，只要读24即可，然后24跟需要写入的25、26进行异或运算可以算出奇偶校验块的值，就直接写入25、26和P，由原来的8个I/O操作减少到4个。

RAID-5:python2 raid.py -R 30 -n 5 -L 5 -S 8k -w 100 -c

同理。

12K

同理，RAID-0和RAID-1都是直接写入三个块，而RAID-4和RAID-5能用到上面说的连续块减少I/O操作的情况更频繁了。

python2 raid.py -R 30 -n 5 -L 0 -S 12k -w 100 -c （ -L 改变即可）

16K

与12K同理。

python2 raid.py -R 30 -n 5 -L 0 -S 16k -w 100 -c （ -L 改变即可）

图略。

当请求大小为16k时，RAID-4和RAID-5效率更高。因为连续的写入4个块，能更多地用到上述的连续块节省I/O的方法。

RAID比较

最后附上各级RAID在容量、可靠性和性能上的对比。