Forwarding versus Stalling

Transcripción

1 Forwarding versus Stalling

2 Dependencias Considerar el siguiente código: 1.sub $2, $1, $3 2.and $12, $2, $5 3.or $13, $6, $2 4.add $14, $2, $2 5.sw $15, 100($2) Las instrucciones 2 a 5 dependen de $2. Universidad de Sonora 2

3 Pipeline Suponer lo siguiente: $2 vale 10 antes de la resta y -20 después. No hay bypass (forwarding). Se puede escribir y leer (en ese orden) un registro en el mismo ciclo. Universidad de Sonora 3

4 Pipeline Los peligros son las líneas que van hacia atrás en el tiempo. Universidad de Sonora 4

5 Bypass El resultado de la resta está listo al final de la etapa EX. Los peligros se resuelven si en cuanto esté listo el resultado se envía a las siguientes instrucciones. Ahora se verá cómo se realiza este envío. El primer paso es detectar los peligros. Universidad de Sonora 5

6 Formatos de instrucción Fijarse en los nombres de los registros del formato R. Fuente: Universidad de Sonora 6

7 Condiciones para peligros 1a. EX/MEM.RegisterRd = ID/EX.RegisterRs. 1b. EX/MEM.RegisterRd = ID/EX.RegisterRt. 2a. MEM/WB.RegisterRd = ID/EX.RegisterRs. 2b. MEM/WB.RegisterRd = ID/EX.RegisterRt. Universidad de Sonora 7

8 Pipeline Aquí se pueden los registros del pipeline y entender las condiciones para peligros Universidad de Sonora 8

9 Ejemplo Para el ejemplo: sub $2, $1, $3 and $12, $2, $5 La condición es: EX/MEM.RegisterRd = ID/EX.RegisterRs = $2. Y por lo tanto hay un peligro. Universidad de Sonora 9

10 Ejemplo Clasificar los peligros en el siguiente código: 1.sub $2, $1, $3 2.and $12, $2, $5 3.or $13, $6, $2 4.add $14, $2, $2 5.sw $15, 100($2) El peligro sub-and es de tipo 1a: EX/MEM.RegisterRd = ID/EX.RegisterRs = $2. El peligro sub-or es de tipo 2b: MEM/WB.RegisterRd = ID/EX.RegisterRt = $2. Universidad de Sonora 10

11 Ejemplos Las dependencias sub-add y sub-sw no generan peligros. Universidad de Sonora 11

12 Consideraciones Hay que tomar en cuenta que no todas las instrucciones escriben en el banco de registros. Por ejemplo beq $t0, $t1, etiqueta add $s0, $t0, $t1 No genera dependencias ni peligros. Esto se resuelve checando si la señal RegWrite va a estar activa en la etapa WB. Universidad de Sonora 12

13 Consideraciones También tomar en cuenta que si el registro destino es $zero ($0) el resultado debe ser siempre cero. Por ejemplo: add $zero, $t0, $t1 sub $s0, $zero, $s1 El resultado de la suma es cero sin importar los valores de $t0 y $t1. La suma no debe enviar el valor de $t0 + $t1 a la resta. Universidad de Sonora 13

14 Consideraciones Esto se resuelve revisando el número del registro: Hay que agregar: EX/MEM.RegisterRd!= 0 a la primera condición. MEM/WB.RegisterRd!= 0 a la segunda condición. Universidad de Sonora 14

15 Condiciones actualizadas 1a. if (EX/MEM.RegWrite and (EX/MEM.RegisterRd!= 0) and (EX/MEM.RegisterRd = ID/EX.RegisterRs)) 1b. if (EX/MEM.RegWrite and (EX/MEM.RegisterRd!= 0) and (EX/MEM.RegisterRd = ID/EX.RegisterRt)) Universidad de Sonora 15

16 Condiciones actualizadas 2a. if (MEM/WB.RegWrite and (MEM/WB.RegisterRd!= 0) and (MEM/WB.RegisterRd = ID/EX.RegisterRs)) 2b. if (MEM/WB.RegWrite and (MEM/WB.RegisterRd!= 0) and (MEM/WB.RegisterRd = ID/EX.RegisterRt)) Universidad de Sonora 16

17 Pipeline con bypass Con lo anterior se pueden detectar los peligros. Falta ver cómo se implementa la unidad de bypass (o unidad de forwarding). Universidad de Sonora 17

18 Pipeline con bypass Universidad de Sonora 18

19 Unidad de bypass Se necesita que las entradas de la ALU puedan venir de otros registros, no sólo de ID/EX. Se colocan multiplexores (muxes) en las entradas de la ALU. Universidad de Sonora 19

20 Datapath sin bypass Fuente: COD 5, p. 309 Universidad de Sonora 20

21 Datapath con bypass Fuente: COD 5, p. 309 Universidad de Sonora 21

22 Líneas de control Fuente: COD 5, p. 310 Universidad de Sonora 22

23 Unidad de bypass La unidad de bypass está en la etapa EX porque ahí están los multiplexores de la ALU. Hay que pasar los operandos: Campo rt (bits [20:16]). Campo rs (bits [25:21]). Universidad de Sonora 23

24 Condiciones Se actualizan las condiciones para detectar peligros: Universidad de Sonora 24

25 Peligro EX 1a. if (EX/MEM.RegWrite and (EX/MEM.RegisterRd!= 0) and (EX/MEM.RegisterRd = ID/EX.RegisterRs)) then ForwardA = 10 1b. if (EX/MEM.RegWrite and (EX/MEM.RegisterRd!= 0) and (EX/MEM.RegisterRd = ID/EX.RegisterRt)) then ForwardB = 10 Universidad de Sonora 25

26 Peligro MEM 2a. if (MEM/WB.RegWrite and (MEM/WB.RegisterRd!= 0) and (MEM/WB.RegisterRd = ID/EX.RegisterRs)) then ForwardA = 01 2b. if (MEM/WB.RegWrite and (MEM/WB.RegisterRd!= 0) and (MEM/WB.RegisterRd = ID/EX.RegisterRt)) then ForwardB = 01 Universidad de Sonora 26

27 Condiciones Las condiciones para el peligro MEM están incompletas. Ocurre si hay un peligro de datos entre: El resultado de la instrucción en la etapa WB. El resultado de la instrucción en la etapa MEM. El operando fuente en la etapa EX. Universidad de Sonora 27

28 Condiciones Por ejemplo, considerar el siguiente código: add $1, $1 $2 add $1, $1, $3 add $1, $1, $3 Todas las instrucciones leen y escriben el mismo registro. Hay que actualizar las condiciones para el peligro MEM. Universidad de Sonora 28

29 Peligro MEM 2a. if (MEM/WB.RegWrite and (MEM/WB.RegisterRd!= 0) and not (EX/MEM.RegWrite and (EX/MEM.RegisterRd!= 0) and (EX/MEM.RegisterRd!= ID/EX.RegisterRs)) and (MEM/WB.RegisterRd = ID/EX.RegisterRs)) then ForwardA = 01 Universidad de Sonora 29

30 Peligro MEM 2b. if (MEM/WB.RegWrite and (MEM/WB.RegisterRd!= 0) and not (EX/MEM.RegWrite and (EX/MEM.RegisterRd!= 0) and (EX/MEM.RegisterRd!= ID/EX.RegisterRt)) and (MEM/WB.RegisterRd = ID/EX.RegisterRt)) then ForwardB = 01 Universidad de Sonora 30

31 Datapath con bypass Fuente: COD 5, p. 311 Universidad de Sonora 31

32 Zoom de EX y MEM Fuente: COD 5, p. 312 Universidad de Sonora 32

33 Tema avanzado Solo se menciona, no vamos a ver la implementación Agregar un bypass del registro MEM/WB a la etapa MEM. Con esto se evitan stalls en una serie de instrucciones lw/sw. Ejemplo: una secuencia para copias memoria/memoria. Universidad de Sonora 33

34 Tema avanzado lw $t0, 0($s0) sw $t0, 0($s1) lw $t0, 4($s0) sw $t0, 4($s1) lw $t0, 8($s0) sw $t0, 8($s1) Universidad de Sonora 34

35 Detención (stall) Cómo se implementa un stall? En la siguiente secuencia: lw $t0, 0($s0) add $t2, $t0, $t1 El peligro de datos no puede resolverse por bypass. Por ejemplo: Universidad de Sonora 35

36 Detención (stall) Fuente: COD 5, p. 313 Universidad de Sonora 36

37 Detención (stall) Se necesita detener (stall) el pipeline por un ciclo. Esto se logra insertando una instrucción nop (no operand) entre lw y add. Se necesita una unidad de detección de peligros. Universidad de Sonora 37

38 Detención (stall) La unidad opera en la etapa ID. La condición es: if (ID/EX.MemRead and ((ID/EX.RegisterRt = IF/ID.RegisterRs) or (ID/EX.RegisterRt = IF/ID.RegisterRt))) detén (stall) el pipeline. Universidad de Sonora 38

39 Detención (stall) La instrucción después de la carga se debe volver a leer al siguiente ciclo. En la detención ni el registro PC ni el registro del pipeline IF/ID deben cambiar. El nop se puede lograr poniendo todas las señales de control de las etapas EX, MEM y WB en 0. Universidad de Sonora 39

40 Cómo se inserta un nop Cómo se inserta un nop. Fuente: COD 5, p. 315 Universidad de Sonora 40

41 Explicación La instrucción AND se convierte en nop. Las instrucciones, comenzando con AND, se retrasan 1 ciclo. El AND y el OR repiten en el ciclo 4 lo que habían hecho en el 3. El AND vuelve a leer decodificarse y leer registros. El OR se vuelve a sacar de la memoria de instrucciones. Universidad de Sonora 41

42 Pipeline La unidad de detección de peligros (HDU) se agrega al pipeline. La unidad de bypass controla los muxes de la ALU. La HDU controla: La escritura a los registros PC y IF/ID. El mux que selecciona entre los valores reales de las señales y puros ceros. La HDU detiene el pipeline y pone las señales de control en 0 si se cumple la condición vista antes. Universidad de Sonora 42

43 Pipeline Fuente: COD 5, p Universidad de Sonora 43