【学习笔记】详细图解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在容量、可靠性和性能上的对比。