Consulte el Conjunto 1 para Ejecución, Etapas y Rendimiento (Rendimiento) y el Conjunto 3 para Tipos de Pipeline y Stalling.
Dependencias en un procesador segmentado
Hay principalmente tres tipos de dependencias posibles en un procesador canalizado. Estos son:
1) Dependencia estructural
2) Dependencia de control
3) Dependencia de datos
Estas dependencias pueden introducir paradas en la canalización.
Stall: Una parada es un ciclo en la canalización sin nueva entrada.
Dependencia estructural
Esta dependencia surge debido al conflicto de recursos en la canalización. Un conflicto de recursos es una situación en la que más de una instrucción intenta acceder al mismo recurso en el mismo ciclo. Un recurso puede ser un registro, una memoria o una ALU.
Ejemplo:
| Instrucción / Ciclo | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|
| yo 1 | SI (Mem) | IDENTIFICACIÓN | EX | Memoria | |
| yo 2 | SI (Mem) | IDENTIFICACIÓN | EX | ||
| yo 3 | SI (Mem) | IDENTIFICACIÓN | EX | ||
| yo 4 | SI (Mem) | IDENTIFICACIÓN |
En el escenario anterior, en el ciclo 4, las instrucciones I 1 e I 4 intentan acceder al mismo recurso (Memoria), lo que genera un conflicto de recursos.
Para evitar este problema, debemos mantener la instrucción en espera hasta que el recurso requerido (memoria en nuestro caso) esté disponible. Esta espera introducirá paradas en la canalización como se muestra a continuación:
| Ciclo | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |
|---|---|---|---|---|---|---|---|---|
| yo 1 | SI (Mem) | IDENTIFICACIÓN | EX | Memoria | WB | |||
| yo 2 | SI (Mem) | IDENTIFICACIÓN | EX | Memoria | WB | |||
| yo 3 | SI (Mem) | IDENTIFICACIÓN | EX | Memoria | WB | |||
| yo 4 | – | – | – | SI (Mem) |
Solución para la dependencia estructural
Para minimizar las paradas de dependencia estructural en la canalización, usamos un mecanismo de hardware llamado cambio de nombre.
Cambio de nombre: De acuerdo con el cambio de nombre, dividimos la memoria en dos módulos independientes utilizados para almacenar la instrucción y los datos por separado llamados Memoria de código (CM) y Memoria de datos (DM) respectivamente. CM contendrá todas las instrucciones y DM contendrá todos los operandos que se requieren para las instrucciones.
| Instrucción/ Ciclo | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
|---|---|---|---|---|---|---|---|
| yo 1 | SI (CM) | IDENTIFICACIÓN | EX | MD | WB | ||
| yo 2 | SI (CM) | IDENTIFICACIÓN | EX | MD | WB | ||
| yo 3 | SI (CM) | IDENTIFICACIÓN | EX | MD | WB | ||
| yo 4 | SI (CM) | IDENTIFICACIÓN | EX | MD | |||
| yo 5 | SI (CM) | IDENTIFICACIÓN | EX | ||||
| yo 6 | SI (CM) | IDENTIFICACIÓN | |||||
| yo 7 | SI (CM) |
Dependencia de control (riesgos de rama)
Este tipo de dependencia ocurre durante la transferencia de instrucciones de control como BRANCH, CALL, JMP, etc. En muchas arquitecturas de instrucción, el procesador no sabrá la dirección de destino de estas instrucciones cuando necesite insertar la nueva. instrucción en la tubería. Debido a esto, se envían instrucciones no deseadas a la canalización.
Considere la siguiente secuencia de instrucciones en el programa:
100: I 1
101: I 2 (JMP 250)
102: I 3
.
.
250: BI 1
Salida esperada: I 1 -> I 2 -> BI 1
NOTA: Generalmente, la dirección de destino de la instrucción JMP se conoce solo después de la etapa de ID.
| Instrucción/ Ciclo | 1 | 2 | 3 | 4 | 5 | 6 |
|---|---|---|---|---|---|---|
| yo 1 | SI | IDENTIFICACIÓN | EX | MEM | WB | |
| yo 2 | SI | Identificación (ordenador personal: 250) | EX | Memoria | WB | |
| yo 3 | SI | IDENTIFICACIÓN | EX | Memoria | ||
| BI 1 | SI | IDENTIFICACIÓN | EX |
Secuencia de salida: I 1 -> I 2 -> I 3 -> BI 1
Entonces, la secuencia de salida no es igual a la salida esperada, eso significa que la canalización no se implementa correctamente.
Para corregir el problema anterior, debemos detener la búsqueda de instrucciones hasta que obtengamos la dirección de destino de la instrucción de bifurcación. Esto se puede implementar introduciendo una ranura de retraso hasta que obtengamos la dirección de destino.
| Instrucción/ Ciclo | 1 | 2 | 3 | 4 | 5 | 6 |
|---|---|---|---|---|---|---|
| yo 1 | SI | IDENTIFICACIÓN | EX | MEM | WB | |
| yo 2 | SI | Identificación (ordenador personal: 250) | EX | Memoria | WB | |
| Demora | – | – | – | – | – | – |
| BI 1 | SI | IDENTIFICACIÓN | EX |
Secuencia de salida: I 1 -> I 2 -> Retardo (Stall) -> BI 1
Como la ranura de retardo no realiza ninguna operación, esta secuencia de salida es igual a la secuencia de salida esperada. Pero esta ranura introduce un estancamiento en la tubería.
Solución para la dependencia del control La predicción de sucursales es el método a través del cual se pueden eliminar las paradas debido a la dependencia del control. En esto, en la primera etapa, se realiza una predicción sobre qué ramal se tomará. Para la predicción de ramal, la penalización de ramal es cero.
Penalización de rama: el número de paradas introducidas durante las operaciones de rama en el procesador canalizado se conoce como penalización de rama.
NOTA: Como vemos que la dirección de destino está disponible después de la etapa de ID, entonces la cantidad de paradas introducidas en la canalización es 1. Supongamos que la dirección de destino de la rama hubiera estado presente después de la etapa ALU, habría 2 paradas. Por lo general, si la dirección de destino está presente después de la k -ésima etapa, habrá (k – 1) paradas en la canalización.
Número total de paradas introducidas en la canalización debido a las instrucciones del ramal = Frecuencia del ramal * Penalización del ramal
Dependencia de datos (riesgo de datos)
Consideremos una instrucción ADD S, tal que
S : ADD R1, R2, R3
Direcciones leídas por S = I(S) = {R2, R3}
Direcciones escritas por S = O(S) = { R1}
Ahora, decimos que la instrucción S2 depende de la instrucción S1, cuando
Esta condición se llama condición de Bernstein.
Existen tres casos:
- Dependencia del flujo (datos): O(S1) ∩ I (S2), S1 → S2 y S1 escribe después de que S2 lea algo
- Antidependencia: I(S1) ∩ O(S2), S1 → S2 y S1 lee algo antes de que S2 lo sobrescriba
- Dependencia de salida: O(S1) ∩ O(S2), S1 → S2 y ambos escriben en la misma ubicación de memoria.
Ejemplo: Sean dos instrucciones I1 e I2 tales que:
I1 : ADD R1, R2, R3
I2 : SUB R4, R1, R2
Cuando las instrucciones anteriores se ejecutan en un procesador segmentado, se producirá una condición de dependencia de datos, lo que significa que I 2 intenta leer los datos antes de que I 1 los escriba, por lo tanto, I 2 obtiene incorrectamente el valor antiguo de I 1 .
| Instrucción / Ciclo | 1 | 2 | 3 | 4 |
|---|---|---|---|---|
| yo 1 | SI | IDENTIFICACIÓN | EX | MD |
| yo 2 | SI | ID (valor antiguo) | EX |
Para minimizar las paradas de dependencia de datos en la canalización, se utiliza el reenvío de operandos .
Reenvío de operandos: en el reenvío de operandos, usamos los registros de interfaz presentes entre las etapas para mantener la salida intermedia para que la instrucción dependiente pueda acceder directamente al nuevo valor desde el registro de interfaz.
Considerando el mismo ejemplo:
I1 : ADD R1, R2, R3
I2 : SUB R4, R1, R2
| Instrucción / Ciclo | 1 | 2 | 3 | 4 |
|---|---|---|---|---|
| yo 1 | SI | IDENTIFICACIÓN | EX | MD |
| yo 2 | SI | IDENTIFICACIÓN | EX |
Riesgos de datos
Los riesgos de datos ocurren cuando las instrucciones que exhiben dependencia de datos, modifican datos en diferentes etapas de una canalización. Peligro de causar retrasos en la tubería. Existen principalmente tres tipos de riesgos de datos:
1) RAW (Lectura después de escritura) [Dependencia de flujo/datos reales]
2) WAR (Escritura después de lectura) [Dependencia antidatos]
3) WAW (Escritura después de escritura) [Dependencia de datos de salida]
Sean dos instrucciones I y J, tales que J siga a I. Entonces,
- El peligro RAW ocurre cuando la instrucción J intenta leer los datos antes de que la instrucción I los escriba.
Ej:
I: R2 <- R1 + R3
J: R4 <- R2 + R3 - El peligro de guerra ocurre cuando la instrucción J intenta escribir datos antes de que la instrucción I los lea.
Ej:
I: R2 <- R1 + R3
J: R3 <- R4 + R5 - El peligro WAW ocurre cuando la instrucción J intenta escribir la salida antes de que la instrucción I la escriba.
Ej:
I: R2 <- R1 + R3
J: R2 <- R4 + R5
Los peligros WAR y WAW ocurren durante la ejecución desordenada de las instrucciones.
Fuentes: goo.gl/J9KVNt
https://en.wikipedia.org/wiki/Hazard_(computer_architecture)
https://en.wikipedia.org/wiki/Data_dependency
Este artículo ha sido aportado por Saurabh Sharma.
Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.
Publicación traducida automáticamente
Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA