4番目の任務
第37章
この章の割り当てでは、提供されている disk.py プログラムを使用する必要があります。このプログラムはディスクの動作をシミュレートできます。デフォルトでは、ディスク スケジューリング方法は FIFO です。時間の計算では、1 度の回転を 1 時間単位と仮定すると、完全な回転には 360 時間単位が必要で、デフォルトではトラック上に 12 セクターがあり、各セクターはデータ送信に 30 時間単位を必要とします。トラック間の距離のデフォルトは 40 単位で、シーク速度は単位時間あたり 1 単位の距離であるため、隣接するトラックのシーク時間は 40 単位時間になります。-G は磁気ヘッドの開始位置が最外周トラックのセクター 6 であることを確認し、シークと回転をシミュレーションできます。起動時の状況は以下の通りです。
1. 次のリクエストのセットのシーク、回転、および転送時間を計算します。
-a 0 ：
磁気ヘッドの開始位置は最外周トラックのセクター6で、セクター0にアクセスする場合はシークする必要はなく、回転遅延を待って回転を待ってデータを送信するだけで済みます。したがって、シーク時間は 0、回転時間は 165 (セクター 6 の中心からセクター 0 の先頭まで回転)、送信時間は 30 です。s はシミュレーションのために実行され、所要時間は予想どおりでした。
-a 6 ：
セクター No. 6 にアクセスすると、開始位置はすでにセクター No. 6 の中心になります。完全なデータを送信するには、345 度回転してからデータの送信を開始する必要があります。したがって、シーク時間は 0、回転時間は 345、転送時間は 30 です。プログラム シミュレーションを実行すると、期待どおりの結果が得られます。
-a 30 ：
セクタ 30 にアクセスするには、セクタ 30 は最も内側のトラックにあります。シークするには 2 つのトラック間の距離 80 を移動する必要があります。このとき、内側のトラックは 80 度回転しています。開始位置に従って、セクタ6 とセクター 30 セクター 30 へのアクセスを開始する前に、同じ方向に 345-80=265 度回転する必要があります。したがって、このリクエストの場合、シーク時間は 80、回転時間は 265、転送時間は 30 です。プログラムを実行すると、期待どおりの結果が得られます。
-a 7,30,8 ：
最初にセクター 7 にアクセスします。シークは必要ありません。15 度回転するだけで送信が開始されます。30秒後にセクター30にアクセスするには、最内周のトラックに移動する必要があり、シークタイムは80です。このとき、開始から15+30+80=125時間が経過しているため、セクター30が回転するまでの待ち時間がかかります。は 345 です。-125=220。送信完了後、セクター8にアクセスするには最外周のトラックに戻る必要があります。この時点で345+30+80=455が経過、つまりセクター9にいます（セクター9の番号+5の位置）度)。セクター 8 のデータを送信するには、310 度回転するまで待つ必要があります。3 回の訪問、シーク時間は 160、回転時間は 15+220+310=545、転送時間は 90。プログラムを実行すると、期待どおりの結果が得られます。
-a 10,11,12,13 ：
最初にセクター 10 と 11 にアクセスします。これら 2 つのセクターは隣接しており、セクター 6 の開始位置と同じトラック上にあります。したがって、シークする必要はありません。データの送信を開始する前に、105 度の回転を待つだけで済みます。 。これら 2 つのセクターのリクエストを処理した後、次のリクエストを処理するために中央のトラックに移動する必要があり、シーク時間は 40 です。中央のトラックに移動すると、105+60+40=205時間が経過し、セクター13(中心から5度)に位置し、開始位置のセクター12に戻ります。320度回転するのを待つ必要があります。 12セクタデータの送信を開始します。したがって、このグループのリクエストを完了するには、シーク時間は 40、待機時間は 105+320=425、送信時間は 120 となります。プログラムを実行すると、期待どおりの結果が得られます。
2. シーク速度を変更し、上記のリクエストを再計算します。
リクエスト キュー -a 0 と -a 6 の場合、開始位置は正しいトラック上にあり、シークは必要ないため、シーク時間は 0 です。シーク時間が変更されても、これら 2 つのリクエストの処理は変更されません。リクエスト キュー -a 30、-a 7、30、8、-a 10、11、12、13 のみが再計算されます。
-a 30 ：
シークレートが 2: セクター 30 が最も内側のトラックにあり、レートが 2 の場合、2 つのトラック間の距離を移動するのに時間 40 かかり、80 になります。このとき、内側のトラックは 40 度回転します。開始位置、セクター 6 と 30 セクター番号 30 は同じ方向にあり、セクター番号 30 へのアクセスを開始するには 345-40=305 度回転する必要があります。したがって、このリクエストの場合、シーク時間は 40、回転時間は 305、転送時間は 30 です。プログラムを実行すると、期待どおりの結果が得られます。
シーク レートは 4 です。トラックの移動時間が 20 に短縮され、データ送信を開始する前に内側のトラックが 345-20=325 度回転する必要があります。シーク時間は 20、回転時間は 325、転送時間は 30 です。
シークレートが８、１０、４０の場合も、シークレートが２、４の場合と同様である。セクター 30 がヘッド位置まで回転するのを待つには 345 度の回転が必要で、シーク時間はこの時間よりも短くなければならないため、シーク時間 + 回転時間 = 345 となります。シーク レートが大きいほど時間は短くなり、回転時間は長くなります。したがって、シーク レートが 8 の場合、シーク時間は 10、回転時間は 335、シーク レート 10 の場合、シーク時間は 8、回転時間は 337、シーク レートが 40 の場合、シークタイムは2、スピンタイムは343です。送信時間は30時間です。質問1に比べてシーク時間が短く、回転時間が長くなっています。
シーク レートが 0.1 の場合、シーク時間は 800 を必要とし、セクター 30 に回転するには 360*2+345-800=265 度の回転が必要です。したがって、この場合、シーク時間は 800、回転時間は 265、転送時間は 30 のままです。
-a 7,30,8 ：
シーク レートは 2 です。セクター 7 にアクセスするには、送信を開始するために 15 度回転する必要があります。30秒後にセクター30にアクセスするには、最内周のトラックに移動する必要があり、シークタイムは40です。このとき、開始から15+30+40=85時間が経過しているため、セクター30が回転するまでの待ち時間がかかります。は 345 です。-85=260。送信終了後、最外周トラックに戻ってセクター8にアクセスすると、345+30+40=415が経過し、このときセクター8(セクター8の位置-5度)では、 350 度回転するまで待つ必要があるので、セクター 8 のデータを送信します。3 回の訪問、シーク時間は 80、回転時間は 15+260+350=625、転送時間は 90。プログラムを実行すると、期待どおりの結果が得られます。
シークレートを変更した場合も上記と同様に、ディスク回転位置とリクエストの処理時間から各リクエストに必要なシーク時間と待ち時間を計算し、再計算します。リクエストの処理には 2 回のシークが必要ですが、これはレートに基づいて直接計算できますが、回転角度を決定するにはシーク時間に基づいて回転時間を計算する必要があります。結果は次のとおりです。
| シークレート |
シークタイム |
スピンタイム |
質問1と比較してください |
| 4 |
0+20+20=40 |
15+280+10=305 |
短いシーク時間、短い回転時間 |
| 8 |
0+10+10=20 |
15+290+20=325 |
短いシーク時間、短い回転時間 |
| 10 |
0+8+8=16 |
15+292+22=329 |
短いシーク時間、短い回転時間 |
| 40 |
0+2+2=4 |
15+298+28=341 |
短いシーク時間、短い回転時間 |
| 0.1 |
0+800+800=1600 |
15+220+310=545 |
長いシーク時間 |
上記の結果によると、シークが速い場合は、適切なセクターに回転する前に常に正しいトラックに到達しますが、それでもセクターがヘッドの下で回転するまで待つ必要があり、シークが速いほど、必要なセクターを取得するために 1 回だけ回転する必要がある場合、回転する必要がある角度は固定されています。つまり、シーク時間 + 回転時間 = 固定セクターを回転するのに必要な時間です。したがって、最初のいくつかのケースでは、シーク時間 + 回転時間 = 345 となります。最後のケースでは、シーク時間が非常に長く、回転に必要な角度が変化するため、時間も異なります。
最後のデータセットの計算結果はプログラムの実行結果とは異なります。プログラムでの実際のシークには 801 単位の時間がかかりましたが、全体的な状況は一貫しています。
-a 10,11,12,13 ：
シーク レートは 2 です。セクター 10 と 11 にアクセスするのにシークは必要ありません。105 度の回転を待つだけです。これら 2 つのセクターのリクエストを処理した後、次のリクエストを処理するために中央のトラックに移動する必要があります。シーク時間は 20 です。中央のトラックに移動すると、セクター 13 から 10 度離れた 105+60+20=185 時間が経過します。セクター 12 の開始位置に戻るには、340 度回転するまで待つ必要があります。したがって、このグループのリクエストを完了するには、シーク時間は 40、待機時間は 105+340=445、送信時間は 120 となります。プログラムを実行すると、期待どおりの結果が得られます。
このグループのリクエストの処理を他のシーク レートで計算すると、結果は次のようになります。
| シークレート |
シークタイム |
スピンタイム |
質問1と比較してください |
| 4 |
0+0+10+0=10 |
105+0+350+0=455 |
シーク時間は短く、回転時間は長い |
| 8 |
0+0+5+0=5 |
105+0+355+0=460 |
シーク時間は短く、回転時間は長い |
| 10 |
0+0+4+0=4 |
105+0+356+0=461 |
シーク時間は短く、回転時間は長い |
| 40 |
0+0+1+0=1 |
105+0+359+0=464 |
シーク時間は短く、回転時間は長い |
| 0.1 |
0+0+800+0=800 |
105+0+320+0=425 |
長いシーク時間 |
プログラムを実行すると、計算が正しいことを確認できます。同様に、最後のデータセットにはプログラム結果からの偏差が 1 あり、プログラムのシークには 801 回かかりました。
3. 回転数を変更する
プログラムを直接実行して結果を取得します。
-a 0 ：
セクター 0 にアクセスするには、ディスクが 165 度回転するまで待つ必要があります。異なる回転速度では、シーク時間は 0 になり、回転時間と送信時間はそれぞれ異なる回転速度に基づきます。
スピンレート 0.1: スピン時間 1650、転送時間 300
スピンレート 0.5: スピン時間 330、転送時間 60
スピンレート 0.01: スピン時間 16500、転送時間 3000
-a 6 ：
セクター 0 へのアクセスと同様に、シーク時間は 0 で、回転時間は次のように変化します。
スピンレート 0.1: スピン時間 3450、転送時間 300
スピンレート 0.5: スピン時間 690、転送時間 60
スピンレート 0.01: スピンタイム 34500、トランスファータイム 3000
-a 30 ：
最初のシークのシーク時間は 80 で、その後の回転速度に応じた回転時間と送信時間は次のようになります。
スピンレート 0.1: スピン時間 3370、転送時間 300
スピンレート 0.5: スピン時間 610、転送時間 60
スピンレート 0.01: スピン時間 34420、転送時間 3000
-a 7,30,8 ：
最初にセクター 7 にアクセスし、15 度回転して送信が完了するのを待つ必要があります。次に、前の回転時間に基づいて内側に移動し、セクター 30 まで回転するのに必要な時間を計算し、最後に外側のトラックに戻ります。 、回転を計算して 8 セクター番号に必要な時間を計算します。シーク時間は回転速度によって変化せず、常に 160 です。結果は次のとおりです。
スピンレート 0.1: スピン時間 3290、転送時間 900
スピンレート 0.5: スピン時間 1250、転送時間 180
スピンレート 0.01: スピン時間 34340、転送時間 9000
-a 10,11,12,13 ：
セクター 10 と 11 にアクセスした後、中央のトラックに移動し、回転を待ち、セクター 12 と 13 へのアクセス要求を処理します。シーク時間は両方とも 40 で、回転時間と転送時間は次のとおりです。
スピンレート 0.1: スピン時間 4610、転送時間 1200
スピンレート 0.5: スピン時間 890、転送時間 240
スピンレート 0.01: スピン時間 46460、転送時間 12000
上記の要求群によれば、回転速度の低下により回転時間と送信時間が大幅に増加し、シークが速いため回転角度は小さくなる可能性がありますが、回転時間は依然として非常に長くなります。
4. スケジュール ポリシーを SSTF に変更します。
デフォルトは FIFO スケジューリング ポリシーです。リクエストのグループ -a 7、30、8 の場合、最初にセクター 7 へのアクセスが処理され、次に最も内側のトラックのセクター 30 へのアクセスが処理され、最後に外側のトラックに戻ってアクセスされます。セクター8。セクター。シークは2回必要ですが、セクタ7にアクセスした後、直接セクタ8にアクセスするとシーク1回が短縮され、回転時間も短縮されます。
セクター7とセクター8に連続アクセスすると回転15回、送信回数60回で済み、その後内周トラックに移動するとシーク40回となり、初期位置と比べて155度回転してセクター30に移動しました。時間は345-155=190。7、8、30 の順序でリクエストを処理するには、合計 40 のシーク時間、205 の回転時間、90 の送信時間が必要となり、7、30、8 の順序に比べて全体の時間が大幅に短縮されます。最短シークファースト (SSTF) 戦略を使用すると、リクエストは次の順序で処理されます。
python3 ./disk.py -a 7,30,8 -p SSTF -G は、最短シーク優先スケジューリングを使用してプログラムを実行します。
リクエストが処理される順序は 7、8、30 です。
5. スケジューリング戦略を SATF に変更します。
スケジューリング ポリシーを SATF に変更します。リクエスト 7、30、および 8 のグループの処理順序は、SSTF を使用する場合と同じ (7、8、および 30) です。この順序でリクエストを処理すると、シークが最短になります。そして回転時間。
SSTF ポリシーは、ローテーション時間に関係なく、常に最新のトラック上のリクエストを処理のために選択します。シーク時間が短く、最も近いトラックでのリクエストに必要な回転時間が非常に長く、遠いトラックでの回転時間が短い場合は、最初に遠いトラックでリクエストを処理してから、次の処理に進む方がよいでしょう。より良いスケジューリング、つまり、最初に最短のアクセス時間に従ってスケジューリングします。したがって、この場合の一連のリクエストでは、SATF の方が SSTF よりもパフォーマンスが高くなります。
磁気ヘッドの開始位置はセクタ番号６である。中トラックのセクタ番号１８へのアクセス要求があり、内周トラックのセクタ番号３４へのアクセス要求があったとする。SSTF の場合、リクエストの処理順序は 18,34 である必要があり、SATF の場合、リクエストの順序は 34,18 である必要があります。セクター番号 18 の要求を最初に処理するには長い待ち時間が必要となるため、セクター番号 34 を最初に処理する SATF スケジューリング戦略は SSTF よりも優れたパフォーマンスを発揮するはずです。プログラムを実行するには、まず SSTF スケジュール戦略を使用します。
処理要求の順序は 18,34 です。スピン時間は 355、シーク時間は 80、合計時間は 495 です。次に SATF スケジューリング戦略を使用します。
リクエストの処理順序は 34,18 です。ただし、リクエストの処理に最も近いトラックが選択されないため、シーク時間が 1 回増えるとシーク時間は 120 と SSTF より長くなりますが、回転時間は 195 と短いため、最終的な処理時間は 195 です。リクエストはわずか 375 であり、SSTF よりも大幅に優れています。
大きな違いの理由は、SSTF がシーク時間が最も短いリクエストを優先し、ローテーション時間を考慮していないためです。ローテーション時間に比べてシーク時間が短く、ローテーション時間が長い場合、ローテーション時間に基づいてどのリクエストを処理するかを考慮する SATF は、シーク時間のみを考慮する SSTF よりもパフォーマンスが高くなります。したがって、大きな差が生じる条件は、回転時間に比べてシーク時間が短いリクエストのセットです。また、シーク時間が回転時間よりも短い場合、その差はさらに顕著になります。
6. トラックスキュー
リクエスト 10、11、12、13 のグループがうまく処理されなかったのは、セクタ 12 と 13 がセクタ 10 と 11 とは異なるトラック上にあり、円周上の角度が連続しているためです。セクター番号 11 は、セクター番号 12 と 13 が配置されているトラックに移動するためにシーク時間を必要とし、これら 2 つのセクターはシーク中にすでに回転しているため、処理する前にさらに 1 週間の回転を待つ必要があります。
この問題を解決する方法は、トラック偏向を導入して、セクタ 12 および 13 がセクタ 10 および 11 と角度的に連続していませんが、ある角度だけ傾いているようにすることです。シーク時の回転はこの角度よりも小さくなります。セクタ番号 12 が完了すると、この問題を解決するためにほぼ 1 回転することなく、要求処理のために磁気ヘッドに迅速に転送できます。デフォルトのシーク レートは 1 です。隣接するトラック間を移動するには 40 単位の時間がかかります。トラックの偏向が 40 度より大きい場合、セクター 11 の要求が処理され、開始にちょうど間に合うように中央のトラックに移動できます。セクター 12 を処理しています。セクター要求。1 つのセクターが 30 度の場合、問題を解決するには 2 セクターのトラック オフセットを取得します。トラック スキューを 2 に設定してプログラムを実行します。トラック スキューが導入された後、シークが完了したときにセクター 12 はヘッドを回転していません。したがって、回転時間 20 を待つ限り、セクター 12 に対する要求は可能です。処理される。リクエストを処理する最終時間は 285 時間で、トラック スキューを追加しない場合の時間 585 よりもはるかに短くなります。
上記の分析によれば、リクエストの合計時間を短縮するには、トラックの偏向角度はシーク時間中に回転する角度より大きくする必要があります。シーク速度を v、トラック間距離を s、回転速度を p とすると、シーク時間中に回転する角度は p*(s/v) となります。トラックに n 個のセクタがあり、セクタの角度が 360/n、スキュー トラックの数が x に設定されていると仮定すると、p*(s/v) < (360/n)*x、x は次のようになります。不等式が成立する最小値。
したがって、トラック スキューは次の式を使用して計算できます。
x > pns 360 v
、 x は不等式を真にする最小の整数値をとります
第38章
この章では、RAID の動作条件をシミュレートできる RAID シミュレータを提供します。パラメーターを指定することで、ワークロードがランダムか順次かを指定したり、ディスクの数、RAID レベル、リクエストの数、書き込みリクエストかどうかなどを指定したりできます。
1. 基本的な RAID マッピング テスト
RAID0
まず RAID0 マッピングをテストします。RAID0 ストライピングでは、連続したデータ ブロックが異なるディスクに順番に分散されてストライプを形成します。したがって、RAID0 のマッピングは次のようになります。
ディスク番号 = アドレス% ディスク番号
オフセット = アドレス/ディスク数
テストには 5 つのリクエストを使用し、リクエストのアドレス範囲を 20 に制限します。エミュレータによって生成されたリクエストに基づいて、リクエストを処理するディスクを計算して検証します。python3 ./raid.py -n 5 -L 0 -R 20 を実行してテストします。
マッピングに基づいて計算が実行されます。デフォルトでは、ディスクの数は 4 です。結果は次のようになります。
| 住所 |
ディスク番号 |
オフセット |
| 16 |
0 |
4 |
| 8 |
0 |
2 |
| 10 |
2 |
2 |
| 15 |
3 |
3 |
| 9 |
1 |
2 |
-c を追加して、マッピングが正しいことを確認します。
襲撃1
RAID1 マッピングを検討してください。RAID1 では、2 つの隣接するディスクがミラー ペアを形成し、データ ブロックの 2 つのコピーが保存され、これに基づいてストライピングが実行されます。したがって、マッピング関係は次のようになります。
ディスク番号 = 2*アドレス% ディスク番号 (両方のコピーが使用可能)
オフセット = 2*アドレス/ディスク数
RAID1 ミラーリングではデータ ブロックのコピーが 2 つあるため、要求されたデータ ブロックのコピーを保持する任意のディスクが要求を処理でき、どのディスクの選択はランダムです。また、テストには 5 つのリクエストを使用し、リクエストのアドレス範囲を 20 に制限します。エミュレータによって生成されたリクエストに基づいて、リクエストを処理するディスクを計算して検証します。python3 ./raid.py -n 5 -L 1 -R 20 を実行してテストします。つまり、以前のセットと同じリクエストを引き続き使用し、マッピング ルールに従って計算が行われます。
| 住所 |
ディスク番号 |
オフセット |
| 16 |
0/1 |
8 |
| 8 |
0/1 |
4 |
| 10 |
0/1 |
5 |
| 15 |
2/3 |
7 |
| 9 |
2/3 |
4 |
-c を追加して、マッピングが正しいことを確認します。
RAID4
RAID4 の場合、1 つのディスクはパリティ ブロックの保存に使用され、残りのディスクはデータ ブロックをストライプ方式で保存します。したがって、各ストライプはマッピング中に 1 つのディスクをスキップする必要があります。
ディスク番号 = アドレス % (ディスク数 - 1)
オフセット = アドレス/(ディスク数 - 1)
上記のリクエストもテストに使用します。アドレスとディスク処理リクエストは次のとおりです。
| 住所 |
ディスク番号 |
オフセット |
| 16 |
1 |
5 |
| 8 |
2 |
2 |
| 10 |
1 |
3 |
| 15 |
0 |
5 |
| 9 |
0 |
3 |
-c 検証を使用すると、結果は計算結果と同じになります。
RAID5
RAID5 の左非対称レイアウトを指定し、リクエストをシーケンシャル リクエストに変更し、20 個のリクエストを生成し、-c を追加してディスク番号とオフセットを取得します。これにより、各ブロック リクエストが RAID5 内の場所を見つけ、それに基づいてブロック リクエストを結論付けることができます。 RAID5 左非対称レイアウト。python3 ./raid.py -n 20 -L 5 -R 20 -5 LA -W seq -c を実行し、結果を RAID 構造に入力すると、次のように RAID5 の左側の非対称レイアウトを取得できます。
| ディスク0 |
ディスク1 |
ディスク2 |
ディスク3 |
| 0 |
1 |
2 |
P1 |
| 3 |
4 |
P2 |
5 |
| 6 |
P3 |
7 |
8 |
| P4 |
9 |
10 |
11 |
| 12 |
13 |
14 |
P5 |
| 15 |
16 |
P6 |
17 |
| 18 |
P7 |
19 |
20 |
同様に、 python3 ./raid.py -n 20 -L 5 -R 20 -5 LS -W seq -c を実行すると、次のように RAID5 左対称レイアウトを取得できます。
| ディスク0 |
ディスク1 |
ディスク2 |
ディスク3 |
| 0 |
1 |
2 |
P1 |
| 4 |
5 |
P2 |
3 |
| 8 |
P3 |
6 |
7 |
| P4 |
9 |
10 |
11 |
| 12 |
13 |
14 |
P5 |
| 16 |
17 |
P6 |
15 |
| 20 |
P7 |
18 |
19 |
RAID5 の左対称レイアウトと左非対称レイアウトの違いは、主にデータ ブロックの分散にあると比較できます。左対称分散では、データ ブロックが順番に異なるディスクに分散され、次のデータ ブロックが次のディスクに配置されます。最後のディスクまで。左非対称分散では、次のブロックのディスクにパリティ ブロックが格納されている場合、次のディスクはスキップされます。
2. チャンクのサイズを変更する
默认情况下大块只有1个块，如果将大块的大小变大，则在条带化时在磁盘上放一个大块大小的块，然后才移动到下一个磁盘进行放置。采用与上题中同样的方式，使用连续的请求，通过处理请求的磁盘号和偏移，可以得出RAID的映射。将大块的大小设置为两块的大小(8192)，进行测试。
RAID0：
python3 ./raid.py -n 20 -L 0 -R 20 -W seq -c -C 8192
映射情况如下：
| 磁盘0 |
磁盘1 |
磁盘2 |
磁盘3 |
| 0 |
2 |
4 |
6 |
| 1 |
3 |
5 |
7 |
| 8 |
10 |
12 |
14 |
| 9 |
11 |
13 |
15 |
RAID1:
python3 ./raid.py -n 20 -L 1 -R 20 -W seq -c -C 8192
相同的，可以得到RAID1大块为2块的映射情况，在镜像的基础上，每对镜像磁盘放置两块，然后移动到下一对镜像磁盘放置数据块。
| 磁盘0 |
磁盘1 |
磁盘2 |
磁盘3 |
| 0 |
0 |
2 |
2 |
| 1 |
1 |
3 |
3 |
| 4 |
4 |
6 |
7 |
| 5 |
5 |
7 |
7 |
RAID4
python3 ./raid.py -n 20 -L 4 -R 20 -W seq -c -C 8192
映射情况如下：
| 磁盘0 |
磁盘1 |
磁盘2 |
磁盘3 |
| 0 |
2 |
4 |
P |
| 1 |
3 |
5 |
P |
| 6 |
8 |
10 |
P |
| 7 |
9 |
11 |
P |
RAID5
python3 ./raid.py -n 20 -L 5 -R 20 -W seq -c -C 8192 -5 LA
映射情况如下：
| 磁盘0 |
磁盘1 |
磁盘2 |
磁盘3 |
| 0 |
2 |
4 |
P |
| 1 |
3 |
5 |
P |
| 6 |
8 |
P |
10 |
| 7 |
9 |
P |
11 |
| 12 |
P |
14 |
16 |
| 13 |
P |
15 |
17 |
改变大块大小没有改变各级RAID的布局规则，只需要将几个小块看成一个整体，映射情况没有发生改变。
3.反转问题
-r反转后，问题为给出磁盘号和磁盘偏移，计算地址。已知映射关系以及RAID布局的情况下，只需要从布局中找到RAID中某个磁盘特定位置保存的地址，或使用映射公式计算。
RAID0：
地址 = 磁盘数*偏移 + 磁盘号，据此就可以算出1中的地址。
RAID1：
地址 = (磁盘数*偏移 + 磁盘号)/2
RAID4：
地址 = (磁盘数-1)*偏移 + 磁盘号 (可能有1的偏差，因为不确定条带前面是否已有校验块)
RAID5：
可以根据不同的布局直接找到地址。
4.改变请求大小
本题要求改变请求的大小，并使用-r反转，即观察不同大小的请求磁盘I/O的情况以及不同RAID级别下磁盘I/O的情况。
8K：
将请求的大小增大到8K，观察不同级别RAID的磁盘处理请求的情况。首先是RAID0级别，对于RAID0级别，请求大小为2个块，而一个磁盘单次处理一个块的请求，因此需要两次I/O完成8K的请求。运行：python3 ./raid.py -n 5 -L 0 -R 20 -r -S 8K，再加上-w 100观察写请求的处理情况：
读与写的情况是类似的，都需要2次I/O才能完成请求。
接下来查看RAID1级别的情况。对于读请求，RAID1只需要磁盘的2次读操作读出两个块的数据，对于写请求，由于每个块有两个副本，需要四次写操作才能完成请求。
对于RAID4，读请求的情况是一样的，不管是顺序读还是随机读，都是两次读完成。
处理写请求不同，由于RAID4以校验块的方式提供冗余，在写入时，需要重写校验块。一种方式是减法奇偶校验，需要读取原来的数据块，原来的校验位，再写入新的块与校验位，共4次写。另一种是加法奇偶校验，读取另外的数据块(比如写数据块2，需要读数据块0和1)，校验后将数据块和校验块并行写入。
可以看到，实际上只有一个写请求进行了8次写，剩下的请求都只需要4次写。这是因为写入时，对于同一条带上的连续两块进行写入，只需要读取一块，与其他两块(需要写入的2块)进行异或，然后将两块和校验块同时写入，即采用加法奇偶校验方法。因此只需要4次I/O。下面分别在磁盘阵列中查看请求写地址8的数据和请求写地址16的数据，写地址8的数据采用减法奇偶校验，因此通过8次写完成请求，而地址16的请求可以采用加法奇偶校验处理，只需要4次写。
| 磁盘0 |
磁盘1 |
磁盘2 |
磁盘3 |
| 0 |
1 |
2 |
P |
| 3 |
4 |
5 |
P |
| 6 |
7 |
8(读-写) |
P(读-写) |
| 9(读-写) |
10 |
11 |
P(读-写) |
| 12 |
13 |
14 |
P |
| 15(读) |
16 (写) |
17(写) |
P(写) |
接下来考虑顺序写入，与随机写类似，加法奇偶校验写入操作数更少，就采用加法奇偶校验写入的方式进行写入，否则还是需要8次写（两个数据块不在同一条带上时，加法奇偶校验与减法奇偶校验写操作数相同）：
RAID5与RAID4的读写情况都是相同的：
12K：
接下来将请求大小修改为12K，对于RAID0与RAID1，只是需要多对一个块进行处理。因此与8K类似，RAID0需要3次I/O完成请求，RAID1需要3次读操作完成读请求，6次写操作完成写请求。
RAID4的随机读和顺序读也与8K类似，需要3次读完成。随机写有所不同，如果在同一个条带上进行写，那只需要三个块进行异或，然后一次将包括校验块在内的四个块全部写入，故需要4次写。如果有2个块在同一条带上，那么这两个块的写入可以采取加法奇偶校验(4次写操作)，另一个单独在其他条带的块不论采用哪种方式，都需要4次写操作，故一共8次写操作。
RAID4顺序写时，写操作数明显减少了，因为每次请求都是对一个条带上的三个块进行写请求，可以采用全条带写入，即直接将三个块异或，然后全部和奇偶校验块一起写入。
RAID5的情况与RAID4是相同的。
16K：
对于16K的请求，RAID0与RAID1的情况没有发生变化，只是需要多处理一个块。RAID0完成请求需要4次I/O。RAID1完成读需要4次读操作，完成写需要8次写操作。
RAID4的随机读和顺序读4次读操作完成。随机写时，有以下2种情况：
| 磁盘0 |
磁盘1 |
磁盘2 |
磁盘3 |
| 请求1 |
请求1 |
请求1 |
P |
| 请求1 |
请求2 |
请求2 |
P |
| 请求2 |
请求2 |
P |
即一个请求分布在两个条带上，两个条带上的块数分别为3,1，另一种情况是两个条带上的块数分别为2,2。考虑3,1的情况，3个块在同一个条带上可以使用全条带写入(4次写)，剩下一个块4次写单独处理，共8次写。另一种2,2的情况，每一个条带上采用加法奇偶校验，各需要4次写，故也需要8次写。
对于顺序写，情况是与随机写相同的，因为请求大小比1个条带的数据块要多。因此顺序写也是以上的两种模式。
RAID5与RAID4相同。
综合以上的所有分析，对于4个磁盘的情况下，请求块数越接近(小于等于)一个条带的块数，RAID4和RAID5的写性能更好。因为在这种情况下，加法奇偶校验可以比减法奇偶校验使用更少的写操作完成请求，最好的情况下，可以使用全条带写入直接完成写入，而不需要读取数据块。
5.100次读取，比较各级RAID性能
RAID0不提供冗余，因此为RAID性能上限，其他RAID级别的性能情况，具体见下表：
RAID0：python3 ./raid.py -L 0 -t -n 100 -c
RADI1: python3 ./raid.py -L 1 -t -n 100 -c
RADI4: python3 ./raid.py -L 4 -t -n 100 -c
RAID5: python3 ./raid.py -L 5 -t -n 100 -c
以上是随机读的情况，与表中的计算是相符的，RAID4的性能最差。如果是顺序读或者写请求，结果也都是和上表中的情况相符的。
第40章
本章提供的vsfs.py可以观察文件系统状态随各种操作发生而产生的改变。提供的基本操作为创建目录，创建文件，打开关闭文件，写文件，创建硬链接和删除硬链接。程序可以显示inode/数据位图，inodes和数据块来表现文件系统的状态。
1.运行模拟
以随机种子17运行模拟器，可得到文件系统状态的一系列变化，需要确认执行了什么操作。初始状态下只有根目录，没有其他文件。
下一个状态，多了一个inode，指向的文件类型为目录，占用了1号数据块，因此执行的操作是mkdir，创建了子目录u。
下一步操作后多出了一个inode，类型为文件，执行的操作为creat，创建一个新文件a。
接下来a的inode被删除，即删除了文件(unlink)。
下一步是创建根目录的子目录z和s。
接下来的三步，首先创建了文件x(在z中)，然后x的引用+1，即创建了一个硬链接(在u中，与x都指向第4个inode)，然后又删除了这个链接。
最后两步，向文件x中写入了数据v，然后又创建了一个新的文件b(在u中)。
采用其他种子模拟类似。根据目录及inode中的内容变化，可以看出是否创建了新的文件或子目录，从引用数可以看出文件的硬链接有几个，并可以通过数据块中目录的inode编号找到硬链接的位置。
2.显示操作，猜测状态
以种子21运行模拟器，在根据操作，推出文件系统的变化。
请求1为创建子目录o，则文件系统的变化应该如下：
inode bitmap 11000000
inodes [d a:0 r:3][d a:1 r:2][][][][][][]
data bitmap 11000000
data [(.,0) (..,0) (o,1)][(.,1) (..,0)][][][][][][]
请求2为创建文件b，只有inode被创建，还没有文件内容：
inode bitmap 11100000
inodes [d a:0 r:3][d a:1 r:2][f a:-1 r:1][][][][][]
data bitmap 11000000
data [(.,0) (..,0) (o,1) (b,2)][(.,1) (..,0)][][][][][][]
请求3在目录o下创建文件q，inode和目录内容都要更新：
inode bitmap 11110000
inodes [d a:0 r:3][d a:1 r:2][f a:-1 r:1][ f a:-1 r:1][][][][]
data bitmap 11000000
data [(.,0) (..,0) (o,1) (b,2)][(.,1) (..,0) (q,3)][][][][][][]
请求4，5向文件b和q写入了数据：
inode bitmap 11110000
inodes [d a:0 r:3][d a:1 r:2][f a:2 r:1][ f a:3 r:1][][][][]
data bitmap 11110000
data [(.,0) (..,0) (o,1) (b,2)][(.,1) (..,0) (q,3)][m][j][][][][]
请求6在目录o下创建了文件j：
inode bitmap 11111000
inodes [d a:0 r:3][d a:1 r:2][f a:2 r:1][ f a:3 r:1][f a:-1 r:1][][][]
data bitmap 11110000
data [(.,0) (..,0) (o,1) (b,2)][(.,1) (..,0) (q,3) (j,4)][m][j][][][][]
请求7删除了文件b的硬链接，由于引用只有1，该文件被删除：
inode bitmap 11011000
inodes [d a:0 r:3][d a:1 r:2][][ f a:3 r:1][f a:-1 r:1][][][]
data bitmap 11010000
data [(.,0) (..,0) (o,1)][(.,1) (..,0) (q,3) (j,4)][][j][][][][]
请求8向文件j写入了数据，假设使用刚刚释放的文件b的数据块：
inode bitmap 11011000
inodes [d a:0 r:3][d a:1 r:2][][ f a:3 r:1][f a:2 r:1][][][]
data bitmap 11110000
data [(.,0) (..,0) (o,1)][(.,1) (..,0) (q,3) (j,4)][g][j][][][][]
请求9在目录o下创建了文件x，假设重复使用已释放的inode：
inode bitmap 11111000
inodes [d a:0 r:3][d a:1 r:2][f a:-1 r:-1][ f a:3 r:1][f a:2 r:1][][][]
data bitmap 11110000
data [(.,0) (..,0) (o,1)][(.,1) (..,0) (q,3) (j,4) (x,2)][g][j][][][][]
最后在目录o下创建了子目录t：
inode bitmap 11111100
inodes [d a:0 r:3][d a:1 r:3][f a:-1 r:-1][ f a:3 r:1][f a:2 r:1][d a:4 r:1][][]
data bitmap 11111000
data [(.,0) (..,0) (o,1)][(.,1) (..,0) (q,3) (j,4) (x,2) (t,5)][g][j][(.,5) (..,1)][][][]
采用其他种子模拟的情况类似，对应各种操作更新文件系统的元数据和数据即可。根据分配情况来看，文件系统会选择最先找到的inode和数据块，即选择复用已经用过了但释放的最近的块用于inode和数据。
3.减少数据块
当数据块很少(2个时)，创建目录会失败，因为创建目录需要分配数据块，而创建文件不会失败，因为创建文件只需要分配inode，不需要分配数据块，但文件不可以写入，没有可用数据块。硬链接和删除链接是可以的，因为链接只需要创建在目录下，指向文件的inode。因此最终只有文件的inode，根目录在文件系统中。
运行：python3 ./vsfs.py -n 100 -c -d 2 ，更换不同的随机种子，可以验证哪些操作是可行的。
创建文件和删除链接可行：
创建硬链接可行：
其他的操作都会失败。
4.减少inode
将inode减少到很少(3个)，文件和目录都难以创建。如果有文件存在，硬链接和删除链接是可行的，对文件进行写也是可行的。下面是只有3个inode的情况，这种情况下，文件和子目录也可以创建，但同时只能有一个文件或子目录存在(最后一个inode不可用，因此除根目录的inode外只有一个可用inode)。
如果只有2个inode，文件和目录将都不可以创建，文件系统的最后一个inode块不可用，最终文件系统只有根目录。