La cuarta tarea
Capítulo 37
La tarea de este capítulo requiere el uso del programa disk.py proporcionado. Este programa puede simular el trabajo de un disco. De forma predeterminada, el método de programación del disco es FIFO. Para el cálculo del tiempo, suponiendo que un grado de rotación es 1 unidad de tiempo, una rotación completa requiere 360 unidades de tiempo, y hay 12 sectores en una pista de forma predeterminada, y cada sector requiere 30 unidades de tiempo para la transmisión de datos. La distancia entre pistas por defecto es 40 unidades y la velocidad de búsqueda es una unidad de distancia por unidad de tiempo, por lo que el tiempo de búsqueda de pistas adyacentes es 40 unidades de tiempo. -G puede ver que la posición inicial del cabezal magnético es el sector 6 de la pista más externa y puede simular la búsqueda y la rotación. La situación de partida es la siguiente:
1. Calcule los tiempos de búsqueda, rotación y transferencia para los siguientes conjuntos de solicitudes.
-a 0 :
La posición inicial del cabezal magnético está en la pista más externa, sector 6. Al acceder al sector 0, no es necesario buscar, solo necesita esperar el retraso de rotación, esperar la rotación y luego transmitir los datos. Por lo tanto, el tiempo de búsqueda es 0, el tiempo de rotación es 165 (girando desde el centro del sector 6 hasta el comienzo del sector 0) y el tiempo de transmisión es 30. s se ejecuta para simulación y el tiempo necesario está en línea con las expectativas.
-a 6 :
Acceda al sector No. 6, y la posición inicial ya está en el centro del sector No. 6. Para transmitir datos completos, debe girar 345 grados y luego comenzar a transmitir datos. Entonces el tiempo de búsqueda es 0, el tiempo de rotación es 345 y el tiempo de transferencia es 30. Al ejecutar la simulación del programa, los resultados son los esperados.
-un 30 ：
Para acceder al sector 30, el sector 30 está en la pista más interna. Es necesario moverse la distancia entre dos pistas, que es 80, para buscar. En este momento, la pista interior se ha girado 80 grados. Según la posición inicial, sector 6 y sector 30 en la misma dirección, debes girar 345-80=265 grados antes de poder comenzar a acceder al sector 30. Entonces, para esta solicitud, el tiempo de búsqueda es 80, el tiempo de rotación es 265 y el tiempo de transferencia es 30. Ejecute el programa y los resultados son los esperados.
-a 7,30,8 ：
Primero acceda al sector 7, no se requiere búsqueda, simplemente gire 15 grados para iniciar la transmisión. Para acceder al sector 30 después de 30 segundos, debes moverte a la pista más interna, el tiempo de búsqueda es 80. En este momento, han pasado 15 + 30 + 80 = 125 desde el inicio, por lo que el tiempo para esperar a que gire el sector 30 es 345. -125=220. Una vez completada la transmisión, debes regresar a la pista más externa para acceder al sector 8. En este momento, han pasado 345 + 30 + 80 = 455, es decir, estás en el sector 9 (la posición del sector 9 número + 5 grados). , debe esperar una rotación de 310 grados antes de poder transmitir los datos del sector 8. Tres visitas, el tiempo de búsqueda es 160, el tiempo de rotación es 15+220+310=545, el tiempo de transferencia es 90. Ejecute el programa y los resultados son los esperados.
-a 10,11,12,13 :
Primero acceda a los sectores 10 y 11. Estos dos sectores son adyacentes y en la misma pista que la posición inicial del sector 6. Por lo tanto, no hay necesidad de buscar, solo necesita esperar la rotación de 105 grados antes de comenzar a transmitir datos. . Después de procesar las solicitudes de estos dos sectores, debe pasar a la vía intermedia para procesar la siguiente solicitud. El tiempo de búsqueda es 40. Al pasar a la pista del medio ha pasado el tiempo 105+60+40=205 y está en el sector 13 (a 5 grados del centro), regresa a la posición inicial del sector 12. Necesita esperar para girar 320 grados. y comenzar a transmitir datos de 12 sectores. Por lo tanto, para completar este grupo de solicitudes, el tiempo de búsqueda es 40, el tiempo de espera es 105+320=425 y el tiempo de transmisión es 120. Ejecute el programa y los resultados son los esperados.
2. Cambie la velocidad de búsqueda y vuelva a calcular la solicitud anterior.
Para las colas de solicitudes -a 0 y -a 6, la posición inicial está en la pista correcta y no se requiere búsqueda, por lo que el tiempo de búsqueda es 0. Si se cambia el tiempo de búsqueda, el procesamiento de estas dos solicitudes no cambiará, por lo que Solo se recalculan las colas de solicitudes -a 30, -a 7,30,8, -a 10,11,12,13.
-un 30 ：
La velocidad de búsqueda es 2: el sector 30 está en la pista más interna. Cuando la velocidad es 2, se necesita un tiempo de 40 para recorrer la distancia entre las dos pistas, que es 80. En este momento, la pista interior gira 40 grados. Según La posición inicial, sector 6 y 30. El sector No. 30 está en la misma dirección y debe girarse 345-40 = 305 grados para comenzar a acceder al sector No. 30. Entonces, para esta solicitud, el tiempo de búsqueda es 40, el tiempo de rotación es 305 y el tiempo de transferencia es 30. Ejecute el programa y los resultados son los esperados.
La velocidad de búsqueda es 4: el tiempo para mover la pista se reduce a 20 y la pista interior debe girar 345-20=325 grados antes de que pueda comenzar la transmisión de datos. El tiempo de búsqueda es 20, el tiempo de rotación es 325 y el tiempo de transferencia es 30.
El caso en el que la tasa de búsqueda es 8,10,40 es similar al caso en el que la tasa de búsqueda es 2,4. Esperar a que el sector 30 gire a la posición de la cabeza requiere una rotación de 345 grados y el tiempo de búsqueda debe ser menor que este tiempo, por lo que tiempo de búsqueda + tiempo de rotación = 345. Cuanto mayor sea la tasa de búsqueda, más corto será el tiempo y mayor será el tiempo de rotación. Por lo tanto, cuando la tasa de búsqueda es 8, el tiempo de búsqueda es 10 y el tiempo de rotación es 335; cuando la tasa de búsqueda es 10, el tiempo de búsqueda es 8 y el tiempo de rotación es 337; cuando la tasa de búsqueda es 40, el El tiempo de búsqueda es 2, el tiempo de giro es 343. El tiempo de transmisión es 30. En comparación con la pregunta 1, el tiempo de búsqueda es más corto y el tiempo de rotación es más largo.
Cuando la tasa de búsqueda es 0,1, el tiempo de búsqueda requiere 800 y girar al sector 30 requiere una rotación de 360*2+345-800=265 grados. Entonces, en este caso, el tiempo de búsqueda es 800, el tiempo de rotación es 265 y el tiempo de transferencia sigue siendo 30.
-a 7,30,8 ：
La tasa de búsqueda es 2: acceder al sector 7 requiere una rotación de 15 grados para iniciar la transmisión. Para acceder al sector 30 después de 30 segundos, debes moverte a la pista más interna, el tiempo de búsqueda es 40. En este momento, han pasado 15 + 30 + 40 = 85 desde el inicio, por lo que el tiempo para esperar a que gire el sector 30 es 345. -85=260. Una vez completada la transmisión, regrese a la pista más externa para acceder al sector 8. En este momento, han pasado 345 + 30 + 40 = 415. En este momento, en el sector 8 (la posición del sector 8 número -5 grados), usted Es necesario esperar la rotación de 350 grados, transmitir los datos del sector 8. Tres visitas, el tiempo de búsqueda es 80, el tiempo de rotación es 15+260+350=625, el tiempo de transferencia es 90. Ejecute el programa y los resultados son los esperados.
Cambie la tasa de búsqueda, de la misma manera que arriba, calcule el tiempo de búsqueda y el tiempo de espera necesarios para cada solicitud en función del tiempo que lleva procesar una solicitud combinado con la posición de rotación del disco, y vuelva a calcular. Procesar la solicitud requiere dos búsquedas, que se pueden calcular directamente en función de la velocidad, mientras que el tiempo de rotación debe calcularse en función del tiempo de búsqueda para determinar el ángulo de rotación. El resultado es el siguiente:
| buscar tasa |
tiempo de búsqueda |
tiempo de giro |
Comparar con la pregunta 1 |
| 4 |
0+20+20=40 |
15+280+10=305 |
Tiempo de búsqueda corto, tiempo de rotación corto |
| 8 |
0+10+10=20 |
15+290+20=325 |
Tiempo de búsqueda corto, tiempo de rotación corto |
| 10 |
0+8+8=16 |
15+292+22=329 |
Tiempo de búsqueda corto, tiempo de rotación corto |
| 40 |
0+2+2=4 |
15+298+28=341 |
Tiempo de búsqueda corto, tiempo de rotación corto |
| 0.1 |
0+800+800=1600 |
15+220+310=545 |
largo tiempo de búsqueda |
De acuerdo con los resultados anteriores, se puede encontrar que si la búsqueda es rápida, siempre se alcanzará la pista correcta antes de girar al sector apropiado, pero aún es necesario esperar a que el sector gire debajo del cabezal, y cuanto más rápido sea buscar, mayor será el tiempo de rotación. Si solo necesita rotar una vez para obtener el sector requerido, entonces el ángulo que debe rotarse es fijo, es decir, tiempo de búsqueda + tiempo de rotación = el tiempo requerido para rotar un sector fijo ángulo, por lo que en los primeros casos, busque tiempo + tiempo de rotación = 345. En el último caso, el tiempo de búsqueda es muy largo y el ángulo requerido para rotar ha cambiado, por lo que el tiempo también es diferente.
Los resultados del cálculo del último conjunto de datos son diferentes de los resultados de ejecución del programa. La búsqueda real en el programa tomó 801 unidades de tiempo, pero la situación general es consistente.
-a 10,11,12,13 :
La tasa de búsqueda es 2: no se requiere búsqueda para acceder a los sectores 10 y 11, solo espere la rotación de 105 grados. Después de procesar las solicitudes de estos dos sectores, debe pasar a la vía intermedia para procesar la siguiente solicitud. El tiempo de búsqueda es 20. Al pasar a la pista intermedia, el tiempo ha pasado 105+60+20=185, que está a 10 grados del sector 13. Para volver a la posición inicial del sector 12, debes esperar una rotación de 340 grados. Por lo tanto, para completar este grupo de solicitudes, el tiempo de búsqueda es 40, el tiempo de espera es 105+340=445 y el tiempo de transmisión es 120. Ejecute el programa y los resultados son los esperados.
Calcule el procesamiento de este grupo de solicitudes a otras tasas de búsqueda y los resultados son los siguientes:
| buscar tasa |
tiempo de búsqueda |
tiempo de giro |
Comparar con la pregunta 1 |
| 4 |
0+0+10+0=10 |
105+0+350+0=455 |
Tiempo de búsqueda corto, tiempo de rotación largo |
| 8 |
0+0+5+0=5 |
105+0+355+0=460 |
Tiempo de búsqueda corto, tiempo de rotación largo |
| 10 |
0+0+4+0=4 |
105+0+356+0=461 |
Tiempo de búsqueda corto, tiempo de rotación largo |
| 40 |
0+0+1+0=1 |
105+0+359+0=464 |
Tiempo de búsqueda corto, tiempo de rotación largo |
| 0.1 |
0+0+800+0=800 |
105+0+320+0=425 |
largo tiempo de búsqueda |
Al ejecutar el programa, puede verificar que los cálculos sean correctos. De manera similar, el último conjunto de datos tiene una desviación de 1 con respecto al resultado del programa, y el programa tardó 801 veces en buscarlo.
3. Cambiar la tasa de rotación.
Ejecute el programa directamente para obtener el resultado:
-a 0 :
Para acceder al sector 0, debe esperar a que el disco gire 165 grados. Con diferentes velocidades de rotación, el tiempo de búsqueda es 0, y el tiempo de rotación y el tiempo de transmisión se basan en diferentes velocidades de rotación, respectivamente:
Velocidad de giro 0,1: tiempo de giro 1650, tiempo de transferencia 300
Velocidad de giro 0,5: tiempo de giro 330, tiempo de transferencia 60
Velocidad de giro 0,01: tiempo de giro 16500, tiempo de transferencia 3000
-a 6 :
De manera similar a acceder al sector 0, el tiempo de búsqueda es 0 y el tiempo de rotación cambia:
Velocidad de giro 0,1: tiempo de giro 3450, tiempo de transferencia 300
Velocidad de giro 0,5: tiempo de giro 690, tiempo de transferencia 60
Velocidad de giro 0,01: tiempo de giro 34500, tiempo de transferencia 3000
-un 30 ：
Primero busque, el tiempo de búsqueda es 80, y luego, según la velocidad de rotación, el tiempo de rotación y el tiempo de transmisión son:
Velocidad de giro 0,1: tiempo de giro 3370, tiempo de transferencia 300
Velocidad de giro 0,5: tiempo de giro 610, tiempo de transferencia 60
Velocidad de giro 0,01: tiempo de giro 34420, tiempo de transferencia 3000
-a 7,30,8 ：
Primero visite el sector 7, debe girar 15 grados y esperar a que se complete la transmisión, luego moverse hacia el interior, según el tiempo de rotación anterior, calcular el tiempo necesario para girar al sector 30 y finalmente regresar a la pista exterior. , calcule la rotación a 8 El tiempo requerido para el número de sector. El tiempo de búsqueda no cambia con la velocidad de rotación y siempre es 160. Los resultados son los siguientes:
Velocidad de giro 0,1: tiempo de giro 3290, tiempo de transferencia 900
Velocidad de giro 0,5: tiempo de giro 1250, tiempo de transferencia 180
Velocidad de giro 0,01: tiempo de giro 34340, tiempo de transferencia 9000
-a 10,11,12,13 :
Después de acceder a los sectores 10 y 11, muévase a la pista del medio, espere la rotación y procese las solicitudes para acceder a los sectores 12 y 13. Los tiempos de búsqueda son ambos 40, y los tiempos de rotación y transferencia son los siguientes:
Velocidad de giro 0,1: tiempo de giro 4610, tiempo de transferencia 1200
Velocidad de giro 0,5: tiempo de giro 890, tiempo de transferencia 240
Velocidad de giro 0,01: tiempo de giro 46460, tiempo de transferencia 12000
Según los grupos de solicitudes anteriores, la desaceleración en la velocidad de rotación aumenta en gran medida el tiempo de rotación y el tiempo de transmisión. Aunque el ángulo de rotación puede ser menor porque la búsqueda es rápida, el tiempo de rotación sigue siendo muy largo.
4. Cambie la política de programación a SSTF.
El valor predeterminado es la política de programación FIFO. Para el grupo de solicitudes -a 7, 30, 8, primero se procesará el acceso al sector 7, luego el acceso al sector 30 de la pista más interna y finalmente de regreso a la pista externa para acceder. sector 8. sectores. Se requieren dos búsquedas. Si se accede al sector 8 directamente después de acceder al sector 7, se puede reducir una búsqueda y también se puede reducir el tiempo de rotación.
Acceder continuamente a los sectores 7 y 8 solo requiere 15 tiempos de rotación y 60 tiempos de transmisión, y luego pasar a la pista interior requiere 40 tiempos de búsqueda. En comparación con la posición inicial, se giró 155 grados y se movió al sector 30. La posición requiere rotación. tiempo 345-155=190. Procesar solicitudes del orden de 7,8,30 requiere un tiempo de búsqueda total de 40, un tiempo de rotación de 205 y un tiempo de transmisión de 90. El tiempo total se reduce considerablemente en comparación con el orden de 7,30,8. Utilizando la estrategia de búsqueda más corta primero (SSTF), las solicitudes se procesan en este orden:
python3 ./disk.py -a 7,30,8 -p SSTF -G ejecuta el programa utilizando la primera programación de búsqueda más corta.
El orden en que se procesan las solicitudes es 7,8,30.
5. Cambie la estrategia de programación a SATF
Cambie la política de programación a SATF. Para el grupo de solicitudes 7, 30 y 8, el orden de procesamiento es el mismo que el que usa SSTF, que es 7, 8 y 30. El procesamiento de solicitudes en este orden dará como resultado la búsqueda más corta. y tiempos de rotación.
La política SSTF siempre selecciona la solicitud en la pista más reciente para su procesamiento, independientemente del tiempo de rotación. Si el tiempo de búsqueda es corto, el tiempo de rotación requerido para la solicitud en la pista más cercana es muy largo y el tiempo de rotación en la pista más lejana es más corto, es mejor procesar primero la solicitud en la pista más alejada y luego continuar. volver a la pista más cercana para procesar la solicitud Mejor programación, es decir, programar primero de acuerdo con el tiempo de acceso más corto. Por lo tanto, para un conjunto de solicitudes en este caso, SATF funcionará mejor que SSTF.
La posición inicial del cabezal magnético es en el sector No. 6. Supongamos que hay una solicitud para acceder al sector No. 18 de la pista intermedia, y otra solicitud para acceder al sector No. 34 de la pista interior. Para SSTF, el orden de procesamiento de las solicitudes debe ser 18,34; para SATF, el orden de solicitudes debe ser 34,18. Dado que procesar primero la solicitud para el sector No. 18 requiere un largo tiempo de espera, la estrategia de programación SATF de procesar primero el sector No. 34 debería funcionar mejor que SSTF. Para ejecutar el programa, primero utilice la estrategia de programación SSTF:
El pedido de solicitud de procesamiento es 18,34. El tiempo de giro es 355, el tiempo de búsqueda es 80, el tiempo total es 495. A continuación, utilice la estrategia de programación SATF:
El orden de procesamiento de las solicitudes es 34,18. Aunque debido a que no se selecciona la pista más cercana para procesar la solicitud, el tiempo de búsqueda se vuelve 120, que es más largo que SSTF, con una búsqueda más. Sin embargo, debido al tiempo de rotación más corto, que es solo 195, el tiempo de procesamiento final de la La solicitud es solo 375, que es significativamente mejor que SSTF.
El motivo de la diferencia significativa es que SSTF prioriza las solicitudes con el tiempo de búsqueda más corto y no tiene en cuenta el tiempo de rotación. Si el tiempo de búsqueda es corto en relación con el tiempo de rotación y el tiempo de rotación es largo, un SATF que considera qué solicitud manejar en función del tiempo de rotación funcionará mejor que un SSTF que solo considera el tiempo de búsqueda. La condición que conduce a una diferencia significativa es, por tanto, un conjunto de solicitudes en las que el tiempo de búsqueda es corto en relación con el tiempo de rotación. Y si el tiempo de búsqueda es más corto que el tiempo de rotación, la diferencia será más significativa.
6. Vía sesgada
La razón por la cual el grupo de solicitudes 10, 11, 12 y 13 no se procesó bien es que los sectores 12 y 13 están en trayectorias diferentes de los sectores 10 y 11, y sus ángulos en la circunferencia son continuos. Después de procesar 10 La solicitud de El sector No. 11 requiere un tiempo de búsqueda para moverse a la pista donde se encuentran los sectores No. 12 y 13, y estos dos sectores ya rotaron durante la búsqueda, por lo que deben esperar otra semana de rotación antes de procesar.
La forma de resolver este problema es introducir una desviación de la vía, de modo que los sectores 12 y 13 no sean angularmente continuos con los sectores 10 y 11, sino que estén sesgados en un ángulo. Al buscar, la rotación es menor que este ángulo. Después de que la vía es Una vez completado, el sector No. 12 se puede transferir rápidamente al cabezal magnético para procesar la solicitud sin tener que girar casi una vuelta para resolver este problema. La tasa de búsqueda predeterminada es 1. Se necesitan 40 unidades de tiempo para moverse entre pistas adyacentes. Si la desviación de la pista es superior a 40 grados, la solicitud para el sector 11 se puede procesar y luego mover a la pista intermedia, justo a tiempo para comenzar. sector de procesamiento 12. solicitud del sector. Si un sector tiene 30 grados, entonces tome el desplazamiento de la pista en 2 sectores para resolver el problema. Establezca la inclinación de la pista en 2 y ejecute el programa. Después de introducir la inclinación de la pista, el sector 12 no ha girado el cabezal cuando se completa la búsqueda. Por lo tanto, mientras se espere el tiempo de rotación de 20, la solicitud del sector 12 puede estar procesado. El tiempo final para procesar la solicitud es 285, que es mucho menor que el tiempo 585 sin agregar sesgo de pista.
Según el análisis anterior, el ángulo de desviación de la pista debe ser mayor que el ángulo de rotación durante el tiempo de búsqueda para reducir el tiempo total de la solicitud. Supongamos que la velocidad de búsqueda es v, la distancia entre pistas es sy la velocidad de rotación es p, entonces el ángulo girado durante el tiempo de búsqueda es p*(s/v). Supongamos que una pista tiene n sectores, entonces el ángulo de un sector es 360/n y el número de pistas oblicuas se establece en x, entonces p*(s/v) < (360/n)*x, x debe ser El valor mínimo en el que se mantiene la desigualdad.
Por lo tanto, la desviación de la vía se puede calcular utilizando la siguiente fórmula:
x > pns 360 v
, x toma el valor entero más pequeño que hace que la desigualdad sea verdadera
Capítulo 38
Este capítulo proporciona un simulador de RAID que puede simular las condiciones de trabajo de RAID. Al especificar parámetros, puede especificar si la carga de trabajo es aleatoria o secuencial, especificar la cantidad de discos, el nivel de RAID, la cantidad de solicitudes y si es una solicitud de escritura, etc.
1. Prueba básica de mapeo RAID
RAID0
Primero pruebe el mapeo RAID0. En la división RAID0, los bloques de datos consecutivos se distribuyen en diferentes discos a su vez para formar bandas. Entonces el mapeo para RAID0 es:
Número de disco = dirección% número de disco
Desplazamiento = dirección/número de discos
Utilice 5 solicitudes para realizar pruebas y limite el rango de direcciones de solicitud a 20. Calcule y verifique los discos que manejan solicitudes en función de las solicitudes generadas por el emulador. Ejecute: python3 ./raid.py -n 5 -L 0 -R 20 para probar.
El cálculo se realiza en función del mapeo. Por defecto, el número de discos es 4. El resultado es:
| DIRECCIÓN |
número de disco |
compensar |
| dieciséis |
0 |
4 |
| 8 |
0 |
2 |
| 10 |
2 |
2 |
| 15 |
3 |
3 |
| 9 |
1 |
2 |
Agregue -c para verificar que la asignación sea correcta.
incursión1
Considere el mapeo RAID1. En RAID1, dos discos adyacentes forman un par de espejos, guardando dos copias de bloques de datos y sobre esta base se realiza la división. Por lo tanto la relación de mapeo debería ser:
Número de disco = 2*dirección% número de disco (ambas copias están disponibles)
Desplazamiento = 2*dirección/número de discos
Debido a que en la duplicación RAID1 hay dos copias del bloque de datos, cualquier disco que contenga la copia solicitada del bloque de datos puede manejar la solicitud y la elección de qué disco es aleatoria. Utilice también 5 solicitudes para pruebas, limitando el rango de direcciones de solicitud a 20. Calcule y verifique los discos que manejan solicitudes en función de las solicitudes generadas por el emulador. Ejecute: python3 ./raid.py -n 5 -L 1 -R 20 para probar. Es decir, aún utilizando las mismas solicitudes que el conjunto anterior, los cálculos se realizan de acuerdo con las reglas de mapeo:
| DIRECCIÓN |
número de disco |
compensar |
| dieciséis |
0/1 |
8 |
| 8 |
0/1 |
4 |
| 10 |
0/1 |
5 |
| 15 |
2/3 |
7 |
| 9 |
2/3 |
4 |
Agregue -c para verificar que la asignación sea correcta.
RAID4
Para RAID4, un disco se utiliza para almacenar bloques de paridad y los discos restantes almacenan bloques de datos en forma de franjas. Por lo tanto, cada franja debe omitir un disco durante el mapeo:
Número de disco = dirección % (número de discos - 1)
Desplazamiento = dirección/(número de discos-1)
Utilice también la solicitud anterior para realizar pruebas. La dirección y la solicitud de procesamiento del disco son las siguientes:
| DIRECCIÓN |
número de disco |
compensar |
| dieciséis |
1 |
5 |
| 8 |
2 |
2 |
| 10 |
1 |
3 |
| 15 |
0 |
5 |
| 9 |
0 |
3 |
Con la verificación -c, el resultado es el mismo que el resultado calculado.
RAID5
Especifique el diseño asimétrico izquierdo de RAID5, cambie la solicitud a una solicitud secuencial, genere 20 solicitudes, agregue -c para obtener el número de disco y el desplazamiento, de modo que cada solicitud de bloque pueda encontrar una ubicación en RAID5, según la cual se pueda concluir Diseño asimétrico izquierdo RAID5. Ejecute: python3 ./raid.py -n 20 -L 5 -R 20 -5 LA -W seq -c, complete los resultados en la estructura RAID y podrá obtener el diseño asimétrico izquierdo de RAID5 de la siguiente manera:
| Disco 0 |
Disco 1 |
Disco 2 |
Disco 3 |
| 0 |
1 |
2 |
P1 |
| 3 |
4 |
P2 |
5 |
| 6 |
P3 |
7 |
8 |
| P4 |
9 |
10 |
11 |
| 12 |
13 |
14 |
P5 |
| 15 |
dieciséis |
P6 |
17 |
| 18 |
P7 |
19 |
20 |
De la misma manera, ejecute python3 ./raid.py -n 20 -L 5 -R 20 -5 LS -W seq -c y podrá obtener el diseño simétrico izquierdo de RAID5 de la siguiente manera:
| Disco 0 |
Disco 1 |
Disco 2 |
Disco 3 |
| 0 |
1 |
2 |
P1 |
| 4 |
5 |
P2 |
3 |
| 8 |
P3 |
6 |
7 |
| P4 |
9 |
10 |
11 |
| 12 |
13 |
14 |
P5 |
| dieciséis |
17 |
P6 |
15 |
| 20 |
P7 |
18 |
19 |
Se puede comparar que la diferencia entre el diseño simétrico a la izquierda de RAID5 y el diseño asimétrico a la izquierda está principalmente en la distribución de los bloques de datos. En la distribución simétrica a la izquierda, los bloques de datos se distribuyen en diferentes discos en orden y el siguiente bloque de datos se coloca en el siguiente. disco hasta el último disco. En la distribución asimétrica izquierda, si el siguiente disco de bloque almacena el bloque de paridad, se omite el siguiente disco.
2. Cambia el tamaño de los trozos.
默认情况下大块只有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块不可用，最终文件系统只有根目录。