ELO311 Estructuras de Computadores Digitales. Pipeline (Segmentación)

Transcripción

1 ELO311 Estructuras de Computadores Digitales Pipeline (Segmentación) Tomás Arredondo Vidal Este material está basado en: material de apoyo del texto de David Patterson, John Hennessy, "Computer Organization & Design", (segunda y tercera edición), Morgan Kaufmann, CA materia del curso de Mary Jane Irwin en PSU, EEUU material del curso anterior ELO311 del Prof. Leopoldo Silva

2 Repaso: Procesador Multiciclo En el modelo multiciclo que se describe, cada paso o etapa de ejecución debe emplear un ciclo del reloj. Los datos que se emplearán en los siguientes ciclos del reloj, al ejecutar una determinada instrucción deben ser almacenados en registros adicionales. La ubicación de los registros que definen etapas o ciclos deben ser relativamente equilibrados, ya que esto tiende a minimizar la duración del ciclo del reloj.

3 Repaso: Procesador Multiciclo (cont) Se emplean los siguientes registros adicionales: IR registro de instruccion A y B salidas de la unidad de registros S salida de la unidad de operaciones M registro con dato leido de memoria

4 Repaso: Procesador Multiciclo (cont) Se tienen cinco etapas para la ejecución de instrucciones (no todas las instrucciones usan todas las etapas): Búsqueda de la Instrucción. Lectura de Memoria de Instrucciones y cálculo de dirección de próxima instrucción. Decodificación de la Instrucción y lectura de registros. Ejecución de operaciones y cálculo de la dirección efectiva de Memoria. Lectura de Memoria de Datos o Escritura en Memoria de Datos. Escritura en Registros. La activación de las señales que controlan las transferencias deben efectuarse asociadas a diferentes ciclos del reloj. Para lograr esto es preciso modelar la unidad de control como una máquina secuencial de estados finitos.

5 Repaso: Procesador Multiciclo (cont)

6 Repaso: Procesador Multiciclo (cont)

7 Repaso: Simplificación del Diseño de Control Para una implementación del MIPS ISA Instrucciones pueden tomar de 1 a 20 ciclos del reloj Resultando en maquinas de estados finitos con cientos o miles de estados y muchos mas transferencias entre estados La representación grafica es imposiblemente compleja Por eso se representan las señales de control que son asignadas durante un estado como una instruccion para ser ejecutada por el camino de datos: microinstrucción Ejecutar una microinstrucción es equivalente a asignar las señales de control especificadas por la microinstrucción

8 Repaso: Microprogramación Las microinstrucciones tienen que especificar Las señales que se tienen que asignar (assert) La próxima microinstrucción a ejecutar Cada microinstrucción corresponde a un estado en la MEF y se le asigna un numero de estado (o direccion ) 1. Comportamiento secuencial incrementar el estado (direccion) od la microinstruccion para obtener la direccion de la proxima microinstruccion 2. Saltar (Jump) a la microinstrucción que comienza la ejecución del la próxima instrucción MIPS (estado 0000 o Fetch) 3. Bifurcación (Branch) a una microinstrucción basada en input de microinstrucción y usando tablas de despacho (TD) 4. El conjunto de microinstrucciones que define al MIPS assembler es una microrutina

9 Repaso: Implementación en PLA 1 Control PLA Outputs AddrCtl PCWrite PCWriteCond IorD MemRead MemWrite IRWrite MemtoReg PCSource Op SourceB SourceA RegWrite RegDst Adder Microprogram Counter Addr select logic Op5 Op4 Op3 Op2 Op1 Op0 System clock sequencing control Inst[31-26]

10 Monociclo Ventajas y Desventajas Usa el reloj ineficientemente el ciclo del reloj debe ser determinado para acomodar a la instruccion mas lenta Clk Cycle 1 Cycle 2 Single Cycle Implementation: lw sw Waste Es una perdida (waste) de tiempo ya que algunas unidades funcionales (e.g., sumadores) deben ser duplicados ya que no se pueden compartir en un ciclo pero... Es simple y fácil de entender

11 Multiciclo Ventajas y Desventajas Usa el reloj mas eficientemente el ciclo del reloj debe acomodar a la etapa de instruccion mas lenta Hay que balancear el trabajo hecho en cada etapa Hay que restringir cada etapa a usar una unidad funcional Multiciclo permite Usar unidades funcionales mas de una vez por instrucción si se usan en diferentes ciclos del reloj Usar un reloj mas rápido Que diferentes instrucciones usen diferentes numero de ciclos del reloj Pero requiere registros de estados adicionales, muxes y MEF mas complicada

12 Introducción Pipeline En un pipeline, se ejecutan varias instrucciones, al mismo tiempo. Para esto, se dividen las etapas mediante registros, cada instrucción puede estar ejecutándose en una etapa. Si existen cinco etapas, pueden ejecutarse simultáneamente cinco instrucciones. Para esto es preciso, que cada instrucción pase por las cinco etapas, y que cada etapa tenga su propio control. Para lograr esto, basta en el diagrama de estados, agregar estados en los que no se activen controles.

13 Introducción Pipeline (cont)

14 Las Cinco Etapas de la Instruccion Load Cycle 1 Cycle 2 Cycle 3 Cycle 4 Cycle 5 lw IFetch Dec Exec Mem WB IFetch: Búsqueda (fetch) instrucción y actualizar el PC Dec: Leer registros y decodificar la Instrucción Exec: Ejecutar (R-type); calcular dirección de memoria Mem: Leer/escribir datos desde/hacia memoria datos WB: Escribir datos de vuelta al arreglo de registros

15 Monociclo vs. Multiciclo Implementacion Monociclo: Clk Cycle 1 Cycle 2 Implementacion Multiciclo: lw sw Waste Reloj multiciclo es mas lento que 1/5 del reloj monociclo dado los FFs adicionales en cada etapa Clk Cycle 1 Cycle 2 Cycle 3 Cycle 4 Cycle 5 Cycle 6 Cycle 7 Cycle 8 Cycle 9Cycle 10 lw IFetch Dec Exec Mem WB sw IFetch Dec Exec Mem R-type IFetch

16 Procesador MIPS con Pipeline Comienza la próxima instrucción mientras que todavía esta trabajando en la instrucción actual Mejora la cantidad de trabajo o flujo (throughput) hecho en un tiempo dado Cycle 1 Cycle 2 Cycle 3 Cycle 4 Cycle 5 Cycle 6 Cycle 7 Cycle 8 lw IFetch Dec Exec Mem WB sw IFetch Dec Exec Mem WB R-type IFetch Dec Exec Mem WB Latencia (tiempo de ejecución, retardo, respuesta) no se reduce para cada instrucción individual

17 Monociclo vs Multiciclo vs Pipeline Monociclo: Clk Cycle 1 Cycle 2 Load Store Waste Multiciclo: Cycle 1 Cycle 2 Cycle 3 Cycle 4 Cycle 5 Cycle 6 Cycle 7 Cycle 8 Cycle 9Cycle 10 Clk lw IFetch Dec Exec Mem WB sw IFetch Dec Exec Mem R-type IFetch Pipeline: lw IFetch Dec Exec Mem WB sw IFetch Dec Exec Mem WB Ciclo nulo insertado (waste) R-type IFetch Dec Exec Mem WB

18 Pipeline del MIPS ISA Porque es fácil Todas las instrucción tienen el mismo largo (32 bits) Pocos formatos de instrucciones (tres) con simetría en los formatos Operaciones de memoria ocurren solo en load y store Operandos deben ser alineados en memoria (word aligned), esto causa que una transferencia de datos requiere solo un acceso de memoria Porque es difícil: Riesgos Riesgos estructurales (structural hazards): que pasa si solo tenemos un componente compartido (e.g. memoria,,...) Riesgos de control (control hazards): que pasa con bifurcaciones Riesgos de datos (data hazards): si los operandos de input de una instrucción dependen de una instrucción previa

19 Gráficamente Representar el MIPS Pipeline Nos puede ayudar a responder cosas como: Cuantos ciclos necesitamos para ejecutar este código? Que hace la durante el ciclo 4? Hay un riesgo? Porque ocurre y come se puede arreglar?

20 Porque un Pipeline? Por el flujo (throughput)! Time (clock cycles) I n s t r. Inst 0 Inst 1 Una vez lleno el pipeline, se completa una instrucción por ciclo O r d e r Inst 2 Inst 3 Inst 4 Tiempo para llenar pipeline

21 Riesgos del Pipeline Hay tres riesgos principales que se deben detectar Riesgos estructurales: tratar de usar el mismo recurso Riesgo de control: tratar de tomar una decisión antes de evaluar una condición (e.g. instrucciones de bifurcación) Riesgos de datos: tratar de usar un resultado antes de que este listo Se pueden resolver los riesgos de varias maneras Adelantando (o retardando acción) para resolver riesgo Una solución vía software es insertar una operación nop, se producen cinco etapas nulas (degrada la velocidad de ejecución). Otra solución es detener por un ciclo el fetch insertando un stall (burbuja) en una etapa. Aun otra solución (mas simple) es insertar ciclos de registros (e.g. para sw) o ciclos de memoria (e.g. para inst. tipo R) nulos

22 Riesgos de Datos: Clasificación Riesgos de datos: El riesgo de tipo RAW (read after write) consiste en leer después de escribir, produce conflicto de datos, ya que se lee el valor anterior de un registro. El riesgo WAW (write after write) consiste en escribir después de escribir. Produce la sobre escritura de un registro con un valor anterior El riesgo WAR (write after Read) escribe después lee y produce el leer el valor futuro de un registro, no usando el valor presente.

23 Riesgos de Datos: Clasificación Sea i una instrucción que va a ser procesada y j una instrucción anterior que está en el pipeline Rregs( i ) es el conjunto de registros que son empleados en lectura y Wregs( i ) el conjunto (en el repertorio MIPS, es un solo registro) de registros en que se escribe en la instrucción i, entonces: Existe un riesgo Read after Write en el registro r si: r ε Rregs( i ) Wregs( j ) Existe un riesgo Write after Write en el registro r si: r ε Wregs( i ) Wregs( j ) Existe un riesgo Write after Read en el registro r si: r ε Wregs( i ) Rregs( j )

24 Ejemplo: Riesgos del Pipeline (Tipo R) Las instrucciones tipo R requieren solo cuatro etapas pero esto causa conflictos estructurales con instrucciones LW Se puede insertar un stall en una etapa (solución compleja)

25 Ejemplo: Riesgos del Pipeline (Tipo R) Otra solución mas simple es insertar un ciclo de memoria nulo Para la ejecución de la instrucción store word, en un procesador multiciclo, también se requieren cuatro etapas. No es siempre necesario agregar un ciclo nulo de postescritura a registros, en el caso de registros de latch transparentes se puede dividir su uso en un ciclo, se libera el recurso (escritura) en la primera mitad del ciclo. escritura: Reg lectura: Reg

26 Memoria Unificada Puede Ser Riesgo Estructural Time (clock cycles) I n s t r. lw Inst 1 Mem Reg Mem Reg Mem Reg Mem Reg Leyendo datos de memoria O r d e r Inst 2 Inst 3 Mem Reg Mem Reg Mem Reg Mem Reg Inst 4 Leyendo instrucción de memoria Mem Reg Mem Reg

27 Que tal acceso a registros? Time (clock cycles) I n s t r. O r d e r add Inst 1 Inst 2 add Inst 4

28 Que tal acceso a registros? Time (clock cycles) I n s t r. O r d e r add Inst 1 Inst 2 add Inst 4 Se puede arreglar un riesgo de acceso a registros haciendo escrituras en la primera parte y lecturas en la segunda parte del ciclo

29 Instrucciones de Bifurcación: Riesgos de Control Dependencias atrás en el tiempo son un riesgo I n s t r. O r d e r add beq lw Inst 3 Inst 4

30 Instrucciones de Bifurcación: Riesgos de Control Dependencias atrás en el tiempo son un riesgo I n s t r. O r d e r add beq lw Inst 3 Inst 4

31 Bifurcación: Otras Opciones La bifurcación requiere cuatro etapas, si se determina la igualdad empleando la condición cero generada por la, durante la etapa de memoria de datos (nula obviamente) se actualiza el valor de PC si debe efectuarse la bifurcación. Nuevamente no se requiere la etapa de postescritura en registros ya que no se usa el recurso También la etapa nula de memoria no ocasiona riesgos con la ejecución de otras instrucciones.

32 Bifurcación: Otras Opciones (cont) Para disminuir los riesgos de control es mejor solución detectar la igualdad en la etapa de decodificación y lectura del arreglo de registros y actualizar el valor de PC, en caso de que se efectúe la bifurcación, en la misma etapa. En este caso el beq libera el recurso y memoria. En esta opción, la bifurcación requiere dos ciclos para completarse.

33 Jump: Otras Opciones Un razonamiento análogo se emplea para el salto incondicional (jump). Se actualizará PC en la etapa de decodificación y lectura de registros. En este caso se libera el arreglo de registros, ya que no se emplea por la instrucción jump.

34 Posibles Soluciones Riesgo de Control Soluciones incluyen Detención (stall) La solución por hardware consiste en detener el fetch de la instrucción siguiente a un branch. La solución por software consiste en intercalar nop (s), después de cada branch. Bifurcaciones retardadas No se detiene la ejecución después de una bifurcación; es decir la instrucción siguiente a una bifurcación comienza a ejecutarse siempre. Esta solución (delayed branch) agrega un ciclo por cada branch, si el compilador encuentra una instrucción que sea útil, y que pueda realizarse después del branch. Vaciamiento (flush) La tercera solución es efectuar el fetch, después del branch. Si el salto no se realiza, se continúa la ejecución. Si el salto se realiza, se debe descartar la instrucción leída y volver a efectuar el fetch.

35 Ejemplo: Como Arreglar Riesgo de Control I n s t r. O r d e r add beq

36 Ejemplo: Como Arreglar Riesgo de Control (cont) I n s t r. add beq Se puede arreglar esperando pero afecta el flujo (throughput) O r d e r stall stall lw Inst 3

37 Ejemplo: Riesgo de Control Se tiene:

38 Ejemplo: Riesgo de Control (cont) En este ejemplo: Se requiere tres ciclos de reloj de detención (stall) por cada branch. No puede efectuarse fetch: durante la etapa de decodificación, durante la etapa de cálculo del flag de cero a la salida de la alu de la instrucción beq, y durante la escritura de PC de la instrucción beq que se efectúa en la etapa mem. Sólo en la etapa WR de la instrucción beq puede efectuarse confiablemente el fetch de la instrucción siguiente. La detención puede lograrse evitando leer la memoria de instrucciones, mediante: La deshabilitación de WEIR y desactivando las señales de control que modifican el estado del procesador (WrReg, MemWr). O bien, limpiando el registro IR en la etapa de decodificación del beq. Esto intercala burbujas en el pipeline.

39 Ejemplo: Riesgo de Control (cont) Se soluciona este riesgo de control, deteniendo el procesamiento de las próximas instrucciones hasta que la decisión pueda efectuarse. Tres ciclos de reloj de detención (stall) por cada branch (solución basado en hardware).

40 Ejemplo: Riesgo de Control (cont) La tarea de detención también la puede hacer el compilador, que debe intercalar tres instrucciones nop (no operación) despues de cada beq El diagrama que representa esta situación es similar al visto antes, pero se está ejecutando la instrucción nop. El texto assembler, modificado por el compilador, para asegurar la ejecución sin riesgos de control en la cañería es el siguiente: beq $t1, $t2, loop nop nop nop add $t3, $t4, $t5 #este fetch es seguro. add $t3, $t6, $t3 add $t3, $t8, $t7

41 Ejemplo: Bifurcaciones Retardadas Al finalizar la etapa de decodificación de un branch, se conoce si el salto tendrá o no lugar. Sin embargo, ya se habrá realizado el fetch de la instrucción siguiente no importando si se realiza o no el salto. La mitad de las veces un compilador puede encontrar una instrucción útil para colocar después de un branch, esto en promedio. Si no puede encontrar una instrucción debe intercalar una instrucción que no haga nada (nop). Una técnica para rellenar los huecos en la cañería es que el compilador intercale un nop después de cada branch, y luego intente reemplazar el nop por una instrucción que pueda adelantarse (o retrasarse).

42 Ejemplo: Bifurcaciones Retardadas (cont) Para encontrar una instrucción que se pueda ejecutar después del branch, se mueve hacia el rótulo y se observa si la instrucción puede moverse sin riesgos (se puede hacer con bifurcaciones hacia delante o detrás): addi $t2, $zero,0 ; este addi antes del beqz puede rellenar el NOP beqz $t1, rótulo NOP... rótulo: addi $t2, $t0, 1 ; este addi después del beqz puede rellenar el NOP slt $t1, $t0, $t3 El addi después del beqz puede moverse y remplazar al NOP (sin riesgos) Otra opción es rellenar el NOP, con una instrucción que se encuentre antes de la bifurcación. En el ejemplo, el addi que está antes de la bifurcación, no tiene riesgos y puede moverse, quedando: beqz $t1, rótulo addi $t2, $zero,0... rótulo: addi $t2, $t0, 1 slt $t1, $t0, $t3 No es fácil encontrar instrucciones para rellenar NOPs si hay instrucciones de punto flotante, ya que usan registros separados del procesador central.

43 Ejemplo: Solución Anticipatoria Una mejora en el pipeline es una solución anticipatoria que implica anticipando la comparación, para esto es preciso agregar hardware, que permita generar la condición "equal" en la etapa de decodificación y a la vez escribir el valor de PC.

44 Uso de Registros: Riesgos de Datos El uso de registros también puede causar riesgos de datos Si el arreglo de registros se implementa con latchs transparentes el registro se puede leer y escribir en el mismo registro, en el mismo ciclo. En este tipo de registros la salida se modifica cuando cambia la entrada (modo transparente), entonces lo que se escriba es lo que comienza a salir. Reg escritura: lectura: Reg

45 Uso de Registros: Riesgos de Datos Dependencias atrás en el tiempo son un riesgo I n s t r. O r d e r add r1,r2,r3 sub r4,r1,r5 and r6,r1,r7 or r8, r1, r9 xor r4,r1,r5

46 Uso de Registros: Riesgos de Datos Dependencias atrás en el tiempo son un riesgo I n s t r. O r d e r add r1,r2,r3 sub r4,r1,r5 and r6,r1,r7 or r8, r1, r9 xor r4,r1,r5

47 Manera de Arreglar Riesgo de Datos I n s t r. O r d e r add r1,r2,r3

48 Manera de Arreglar Riesgo de Datos I n s t r. add r1,r2,r3 stall Se puede arreglar esperando pero afecta el flujo (throughput) O r d e r stall sub r4,r1,r5 and r6,r1,r7

49 Uso de Loads: Riesgos de Datos Dependencias atrás en el tiempo son un riesgo I n s t r. O r d e r lw r1,100(r2) sub r4,r1,r5 and r6,r1,r7 or r8, r1, r9 xor r4,r1,r5

50 Riesgos de Datos: Anticipación de Datos La solución de los conflictos de datos, también puede realizarse mediante la anticipación de los datos (requiere hardware adicional). Esto considerando que el dato que será escrito en un registro por una instrucción de tipo R o de tipo inmediata, ya está disponible en el pipeline después de terminada la etapa de operaciones. La anticipación de datos también se puede usar en caso de instrucciones con resultados en la memoria ya que dicho valor está disponible en el pipeline. Esto implica modificar la ruta de datos, para que la pueda adquirir sus datos de entrada desde la salida de la, o desde la salida de la memoria.

51 Ejemplo: Procesador Segmentado con Solución de Riesgos

52 Ejemplo: Riesgos de Datos por registros Se muestran las anticipaciones desde la salida de la (del valor de $t1) y de la salida de la memoria (con el valor de $t1) hacia la entrada de la de las instrucciones siguientes. También se muestra, el efecto anticipatorio, del uso de registros en base a latchs transparentes.

53 Condiciones para anticipar la salida de la Para anticipar la salida de la usando muxes, debe escribirse la salida de la en el registro A (en lugar del busa) si el conflicto es con rs; o en el registro B (en lugar del busb) si el conflicto es con rt. Puede detectarse que la que está en operaciones es de tipo R o inmediata, ya que debe tener MemRd y MemWr iguales a cero y RegWr igual a uno. Cuando en operaciones se tiene una instrucción de tipo R o inmediata que escriba en un registro (RD), y en decodificación una instrucción que lea el registro rs (lee_rs=1) o que lea el registro rt (lee_rt=1). lee_rs = 1 para add, sub, ori, beq, lw lee_rt = 1 para add,sub, beq Cuando en etapa de memoria se tiene una de tipo R o inmediata y en decodificación una instrucción que lee rs o rt, con igual valor al del registro en que se escribirá (RD1).

54 Como anticipar la salida de la Condiciones de detección: Operación de tipo R o inmediata en etapa operación TipoRI = (MemWr==0) & (MemRd==0) & (RegWR==1) Operación de tipo R o inmediata en etapa memoria TipoRI1 = (MemWr1==0) & (MemRd1==0) & (RegWR1==1) Controles de los muxes if (TipoRI ) & (lee_rs) & (rs == RD ) A = Aluout; /*AntA = 1 */ if (TipoRI1) & (lee_rs) & (rs == RD1) A = Mout; /*AntA = 2 */ if (MemRd1==1) && (Cop== sw ) &&(rs == RD1) A = Mout; en el resto de los casos A = R[rs]; /*AntA = 0 */ if (TipoRI ) & (lee_rt) & (rt == RD ) B = Aluout; /* AntB = 1 */ if (TipoRI1) & (lee_rt) & (rt == RD1) B = Mout; /* AntB = 2 */ en el resto de los casos B = R[rt]; /* AntB = 0 */

55 Stores Pueden Causar Riesgos de Datos Las instrucciones que escriben en un registro, seguidas de un store que escriba el contenido del registro aún no grabado Ejemplo: lw $t1,0($t2) sw $t1,0($t3) No se requiere detener la ejecución de la escritura en memoria (sw) si se adelanta la salida de la etapa de memoria (Mout) hacia el registro de segmentación que almacena el valor que será escrito en la memoria (D). Se detecta cuando: La instrucción que escribe en el registro está en la etapa de memoria y el store en etapa de operaciones y si RD1 == RD RD1 = el registro en que escribirá la instrucción que está en etapa de memoria RD = el registro cuyo contenido debe escribirse en memoria y que esta en etapa operaciones

56 Ejemplo: Riesgos de Datos Dependencias atrás en el tiempo son un riesgo I n s t r. lw $t1,0($t2) sw $t1,0($t3) O r d e r addi $t6,$t1,$t3 ori $t8, $t1, $t9 ori $t10,$t9,$t11

57 I n s t r. O r d e r Ejemplo: Riesgos de Datos Dependencias atrás en el tiempo son un riesgo lw $t1,0($t2) RD1 sw $t1,0($t3) RD addi $t6,$t1,$t3 Solución de riesgo: Anticipar la escritura en memoria if ( (MemWr == 1) & (RegWr1==1) & (RD==RD1 ) ) D = Mout; // AntM=1 en el resto de los casos D = B /* AntM = 0 */

58 Detención de un ciclo en secuencias: lw-alu Se detecta el riesgo cuando el lw está en operaciones (MemRd1 en 1) y la instrucción que le sigue (que lea el registro en el cual el lw escribe) en decodificación. Ejemplo: lw $t1,0($t2) add $t2,$t1,$t3 Primero las secuencias lw seguidas por instrucciones que leen el registro rs (tipo R, transferencias, inmediatas y beq); que se detectan por: (MemRd1 == 1) & ( OP!= j) & ( rs ==RD) En segundo lugar las secuencias lw seguidas de instrucciones que leen el registro rt (tipo R y beq) que se detectan según: (MemRd1 == 1) & (Op==tipoR Op==beq ) & ( rt ==RD)

59 Detención de un ciclo en secuencias: lw-alu (cont) Solución de riesgo: Detención de un ciclo en secuencias: lw-alu if ( ( MemRd1 == 1) & ( Op!= j) & ( rs ==RD) ( MemRd1== 1)& ( Op==tipoR Op==beq) & (rt ==RD)) { burbuja = 1; válido = 0;} en el resto de los casos burbuja = 0; válido =1;

60 Descarte (flush) en caso de saltos incondicionales En caso de no ejecutar la instrucción siguiente a un jump, que ya pasó por etapa de fetch deben eliminarse los efectos de la instrucción siguiente, para esto basta que la instrucción que completó su fetch no modifique un registro o escriba en la memoria: if ( PCsel==1)&(Op==j) flush =1;

61 Descarte (flush) en caso de bifurcaciones En caso de no ejecutar la instrucción siguiente a un beq, que ya pasó por la etapa de fetch deben eliminarse los efectos de la instrucción siguiente, para esto basta que la instrucción que completó su fetch no modifique un registro o escriba en la memoria: if ( PCsel==1)&(Op==beq) flush =1; También puede diseñarse, según: if ( Equal==1)&(Op==beq) flush =1;

62 Instrucción No operación (NOP) Esta instrucción tiene los 32 bits iguales a cero. Es de tipo R, con el campo funct = 0. if (Op == nop) { AluCtr=øøø; AluSrc=ø; ExtOp=ø; MemRd = ø; MemWr=0; Memtoreg = ø; RD= 0; RegWr =0; PCsel =0; válido = 0} Además si es nop: rs=0, rt=0, rd =0.

63 Otras Estructuras de Pipeline son Posibles Si se tiene una operación lenta de multiplicación? Dejar que tome dos ciclos MUL Que tal si memoria de datos es dos veces mas lenta que memoria de instrucciones? Hacer el reloj dos veces mas lento o Dejar que la memoria de datos tome dos ciclos (y mantener el mismo ciclo del reloj) IM Reg DM1 DM2 Reg

64 Alternativas de Pipelines ARM7 IM Reg EX PC update IM access decode reg access op DM access shift/rotate commit result (write back) StrongARM-1 XScale PC update BTB access start IM access IM1 IM2 Reg DM1 Reg SHFT DM2 IM access decode reg 1 access op shift/rotate reg 2 access DM write reg write start DM access exception