操作系统作业9

ゝ一世哀愁。 2021-12-24 03:17 268阅读 0赞

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.

首先：RAID0 zsydeMacBook-Pro:HW-Raid zsy$ ./raid.py -n 5 -L 0 -R 20

这是怎么求的呢？

Disk = address % number\_of\_disks

offset = address / number\_of\_disks

所以按照老师给的ppt上是这样的

所以结果应该是：

addr:16

read \[disk 0, offset 4\]

addr:8

read \[disk 0, offset 2\]

addr:10

read \[disk 2, offset 2\]

addr:15

read \[disk 3, offset 3\]

addr:9

read \[disk 1, offset 2\]

RAID1:zsydeMacBook-Pro:HW-Raid zsy$ ./raid.py -n 5 -L 1 -R 20

结果是：

LOGICAL READ from addr:16 size:4096

read \[disk 0, offset 8\]

LOGICAL READ from addr:8 size:4096

read \[disk 0, offset 4\]

LOGICAL READ from addr:10 size:4096

read \[disk 1, offset 5\]

LOGICAL READ from addr:15 size:4096

read \[disk 3, offset 7\]

LOGICAL READ from addr:9 size:4096

read \[disk 2, offset 4\]

RAID4 zsydeMacBook-Pro:HW-Raid zsy$ ./raid.py -n 5 -L 4 -R 20

结果应该：

LOGICAL READ from addr:16 size:4096

read \[disk 1, offset 5\]

LOGICAL READ from addr:8 size:4096

read \[disk 2, offset 2\]

LOGICAL READ from addr:10 size:4096

read \[disk 1, offset 3\]

LOGICAL READ from addr:15 size:4096

read \[disk 0, offset 5\]

LOGICAL READ from addr:9 size:4096

read \[disk 0, offset 3\]

RAID5:

这个有分几种情况：

这是readme给出的

1、左对称（Left-symmetric）；

2、左不对称（Left-asymmetric）；

3、右对称（Right-symmetric）；

4、右不对称（Right-asymmetric）

我要理解的就是左边的一竖列了

其实，在实际使用测试中，校验和的左右布局方式对RAID5 性能没有太大影响。

那么首先LA情况：zsydeMacBook-Pro:HW-Raid zsy$ ./raid.py -n 5 -L 5 -5 LA -R 20

该怎么算呢？

是这个模型，于是可以算出：

LOGICAL READ from addr:16 size:4096

read \[disk 1, offset 5\]

LOGICAL READ from addr:8 size:4096

read \[disk 3, offset 2\]

LOGICAL READ from addr:10 size:4096

read \[disk 2, offset 3\]

LOGICAL READ from addr:15 size:4096

read \[disk 0, offset 5\]

LOGICAL READ from addr:9 size:4096

read \[disk 1, offset 3\]

继续看LS模式：zsydeMacBook-Pro:HW-Raid zsy$ ./raid.py -n 5 -L 5 -5 LS -R 20

恰恰是这种形式，就可以用到之前的公式

不过需要修改一下

disk  = address % number\_of\_disks

offset = address / number\_of\_disks-1

我能够算出答案：

LOGICAL READ from addr:16 size:4096

read \[disk 0, offset 5\]

LOGICAL READ from addr:8 size:4096

read \[disk 0, offset 2\]

LOGICAL READ from addr:10 size:4096

read \[disk 2, offset 3\]

LOGICAL READ from addr:15 size:4096

read \[disk 3, offset 5\]

LOGICAL READ from addr:9 size:4096

read \[disk 1, offset 3\]

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

他的意思是要我在后面-c来改变chunk的大小。

RAID0：zsydeMacBook-Pro:HW-Raid zsy$ ./raid.py -s 1 -n 5 -L 0 -5 LA -R 4 -c -C 8k

因为它变大了，所以相当于：

一个块能装俩，竖着：

01 23 45 67

89 ……

上图为变化前和变化后的比较

RAID1：zsydeMacBook-Pro:HW-Raid zsy$ ./raid.py -s 1 -n 5 -L 1 -5 LA -R 4 -c -C 8k

对比：

RAID4：zsydeMacBook-Pro:HW-Raid zsy$ ./raid.py -s 1 -n 5 -L 4 -5 LA -R 4 -c -C 8k

对比：

RAID5：

LA:zsydeMacBook-Pro:HW-Raid zsy$ ./raid.py -s 1 -n 5 -L 5 -5 LA -R 4 -c -C 8k

看对比：

LS:zsydeMacBook-Pro:HW-Raid zsy$ ./raid.py -s 1 -n 5 -L 5 -5 LS -R 4 -c -C 8k

对比：

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

现在的要求是：要求一个reverse：

-r, --reverse         instead of showing logical ops, show physical

zsydeMacBook-Pro:HW-Raid zsy$ ./raid.py -s 1 -n 5 -L 0 -5 -R 20 -C 4k -r

结果实际是：

LOGICAL READ from addr:1343 size:4096

read \[disk 3, offset 335\]

LOGICAL READ from addr:7637 size:4096

read \[disk 1, offset 1909\]

LOGICAL READ from addr:4954 size:4096

read \[disk 2, offset 1238\]

LOGICAL READ from addr:6515 size:4096

read \[disk 3, offset 1628\]

LOGICAL READ from addr:938 size:4096

read \[disk 2, offset 234\]

说明什么？

其实就是反过来使用规则就可以了

1.  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?

他现在的要求：

increase the size of each request with the -S flag

分别试试8 12 16

下面是实验过程：

zsydeMacBook-Pro:HW-Raid zsy$ ./raid.py -s 1 -n 5 -L 0 -5 -R 20 -C 4k -r -S 8k

下面来分析

Raid0

Raid1:

RAID4：

RAID5:

LR：

12K的情况：

RAID0

RAID1

RAID4

RAID5

所以能得出结论，对于seq的，4和5很像，而且当然是size越大越好

1.  Use the timing mode of the simulator (-t) to estimate the perfor- mance of 100 random reads to the RAID, while varying the RAID levels, using 4 disks.

现在看随机读写：

随机的：读：同时读，除了纠错的那个，所以是（N-1）\*R

Additive parity：读除了要写的disk和纠错disk以外的所有disk，异或他们，写新的parity和磁盘

Subtractive parity：两次读两次写：

最大可以到R/2

一个错误犯了就不能和其他一起修改p，所以不能并行

总之是：一个一个读，写更累赘，需要写一个再补一个+两个读

而且，能发现，R0时间是最少的，当然，他没有容错位，而且也没有冗余。

1.  Do the same as above, but increase the number of disks. How does the performance of each RAID level scale as the number of disks increases?

可以发现磁盘增加之后，能够比较明显的提升时间。

1.  Do the same as above, but use all writes (-w 100) instead of reads. How does the performance of each RAID level scale now? Can you do a rough estimate of the time it will take to complete the workload of 100 random writes?

发现仍然是RAID0最快的，4最差。

1.  Run the timing mode one last time, but this time with a sequen- tial workload (-W sequential). How does the performance vary with RAID level, and when doing reads versus writes? How about when varying the size of each request? What size should you write to a RAID when using RAID-4 or RAID-5?

首先，区分读写：

写

读

发现规律：读比写快（必然的）

仍然是RAID0最快。

现在看16K的情况：

./raid.py -s 1 -n 100 -L 5 -5 LS -R 20 -C 4k -r -S 4k -c -W seq -w 0 -t 100

读

写

发现比起4k，RAID4 RAID5的性能在逐渐追赶RAID0，且考虑到容错的问题，我认为这个时候优先选择RAID5是好的。