ELO311 Estructuras de Computadores Digitales...

ELO311Estructuras 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), MorganKaufmann, CA. 2005

�materia del curso de Mary Jane Irwin en PSU, EEUU

�material del curso anterior ELO311 del Prof. Leopoldo Silva

�www.wikipedia.org

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.

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


�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.

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

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 inputde microinstrucción y usando tablas de despacho (TD)

4. El conjunto de microinstrucciones que define al MIPS assembler es una microrutina

Repaso: Implementación en PLA

ControlPLA

Inst[31-26]

sequencingcontrol

Out

puts

Op0

Op1

Op2

Op3

Op4

Op5

PCWritePCWriteCondIorDMemReadMemWriteIRWriteMemtoRegPCSourceALUOpALUSourceBALUSourceARegWriteRegDst

System clock

Microprogram Counter

1

Adder

Addr select logic

AddrCtl

Monociclo Ventajas y Desventajas

�Usa el reloj ineficientemente – el ciclo del reloj debe ser determinado para acomodar a la instruccion mas lenta

�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

Clk

Single Cycle Implementation:

lw sw Waste

Cycle 1 Cycle 2

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, muxesy MEF mas complicada

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.

Introducción Pipeline (cont)

Las Cinco Etapas de la Instruccion Load

�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

Cycle 1 Cycle 2 Cycle 3 Cycle 4 Cycle 5

IFetch Dec Exec Mem WBlw

Monociclo vs. Multiciclo

Clk Cycle 1

Implementacion Multiciclo:

IFetch Dec Exec Mem WB

Cycle 2 Cycle 3 Cycle 4 Cycle 5 Cycle 6 Cycle 7 Cycle 8 Cycle 9Cycle 10

IFetch Dec Exec Mem

lw sw

Clk

Implementacion Monociclo:

lw sw Waste

IFetch

R-type

Cycle 1 Cycle 2

Reloj multiciclo es mas lento que 1/5 del reloj monociclo dado los FFs adicionales en cada etapa

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

�Latencia (tiempo de ejecución, retardo, respuesta) no se reduce para cada instrucción individual

Cycle 1 Cycle 2 Cycle 3 Cycle 4 Cycle 5

IFetch Dec Exec Mem WBlw

Cycle 7Cycle 6 Cycle 8

sw IFetch Dec Exec Mem WB

R-type IFetch Dec Exec Mem WB

Monociclo vs Multiciclo vs Pipeline

Clk

Cycle 1

Multiciclo:

IFetch Dec Exec Mem WB

Cycle 2 Cycle 3 Cycle 4 Cycle 5 Cycle 6 Cycle 7 Cycle 8 Cycle 9Cycle 10

lw IFetch Dec Exec Mem WB

IFetch Dec Exec Mem

lw sw

Pipeline:

IFetch Dec Exec Mem WBsw

Clk

Monociclo:

Load Store Waste

IFetch

R-type

IFetch Dec Exec Mem WBR-type

Cycle 1 Cycle 2

Ciclo nulo insertado(waste)

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, ALU, ...)

� 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

Gráficamente Representar el MIPS Pipeline

�Nos puede ayudar a responder cosas como:�Cuantos ciclos necesitamos para ejecutar este código?

�Que hace la ALU durante el ciclo 4?

�Hay un riesgo? Porque ocurre y come se puede arreglar?

ALUIM Reg DM Reg

Porque un Pipeline? Por el flujo (throughput)!

Instr.

Order

Time (clock cycles)

Inst 0

Inst 1

Inst 2

Inst 4

Inst 3

ALUIM Reg DM Reg

ALUIM Reg DM Reg

ALUIM Reg DM Reg

ALUIM Reg DM Reg

ALUIM Reg DM Reg

Una vez lleno el pipeline, se completa una instrucción por ciclo

Tiempo para llenar pipeline

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

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.

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 )

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)

Ejemplo : Riesgos del Pipeline (Tipo R)

�Otra solución mas simple es insertar un ciclo de memorianulo

�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 latchtransparentes se puede dividir su uso en un ciclo, se libera el recurso (escritura) en la primera mitad del ciclo.

escritura: lectura:Reg Reg

Instr.

Order

Time (clock cycles)

lw

Inst 1

Inst 2

Inst 4

Inst 3

ALUMem Reg Mem Reg

ALUMem Reg Mem Reg

ALUMem Reg Mem Reg

ALUMem Reg Mem Reg

ALUMem Reg Mem Reg

Memoria Unificada Puede Ser Riesgo Estructural

Leyendo datos de memoria

Leyendo instrucción de memoria

Que tal acceso a registros?

Instr.

Order

Time (clock cycles)

add

Inst 1

Inst 2

Inst 4

add

ALUIM Reg DM Reg

ALUIM Reg DM Reg

ALUIM Reg DM Reg

ALUIM Reg DM Reg

ALUIM Reg DM Reg

Que tal acceso a registros?

Instr.

Order

Time (clock cycles)

add

Inst 1

Inst 2

Inst 4

add

ALUIM Reg DM Reg

ALUIM Reg DM Reg

ALUIM Reg DM Reg

ALUIM Reg DM Reg

ALUIM Reg DM Reg

Se puede arreglar un riesgo de acceso a registros haciendo escrituras en la primera parte y lecturas en la segunda parte del ciclo

Instrucciones de Bifurcación: Riesgos de Control

Instr.

Order

add

beq

lw

Inst 4

Inst 3

ALUIM Reg DM Reg

ALUIM Reg DM Reg

ALUIM Reg DM Reg

ALUIM Reg DM Reg

ALUIM Reg DM Reg

�Dependencias atrás en el tiempo son un riesgo

Bifurcación: Otras Opciones�La bifurcación requiere cuatro etapas, si se

determina la igualdad empleando la condición cero generada por la ALU, 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.

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 ALU y memoria.

�En esta opción, la bifurcación requiere dos ciclos para completarse.

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.

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.

Ejemplo: Como “Arreglar” Riesgo de Control

Instr.

Order

add

beq

ALUIM Reg DM Reg

ALUIM Reg DM Reg

Ejemplo: Como “Arreglar” Riesgo de Control (cont)

Instr.

Order

add

beq

ALUIM Reg DM Reg

ALUIM Reg DM Reg

Inst 3

lw

ALUIM Reg DM Reg

ALUIM Reg DM Reg

Se puede arreglar esperando – pero afecta el flujo (throughput)

stall

stall

Ejemplo: Riesgo de Control�Se tiene:

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.

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).

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

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).

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 NOPbeqz $t1, rótuloNOP...rótulo: addi $t2, $t0, 1 ; este addi después del beqz puede rellenar el NOPslt $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ótuloaddi $t2, $zero,0 ...rótulo: addi $t2, $t0, 1slt $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.

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.

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 latchstransparentes 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.

escritura: lectura:Reg Reg

Uso de Registros: Riesgos de Datos

Instr.

Order

add r1,r2,r3

sub r4,r1,r5

and r6,r1,r7

xor r4,r1,r5

or r8, r1, r9

ALUIM Reg DM Reg

ALUIM Reg DM Reg

ALUIM Reg DM Reg

ALUIM Reg DM Reg

ALUIM Reg DM Reg


Manera de “Arreglar” Riesgo de Datos

Instr.

Order

add r1,r2,r3

ALUIM Reg DM Reg

Manera de “Arreglar” Riesgo de Datos

Instr.

Order

add r1,r2,r3

ALUIM Reg DM Reg

sub r4,r1,r5

and r6,r1,r7

ALUIM Reg DM Reg

ALUIM Reg DM Reg

stall

stall

Se puede arreglar esperando – pero afecta el flujo (throughput)

Uso de Loads: Riesgos de Datos

Instr.

Order

lw r1,100(r2)

sub r4,r1,r5

and r6,r1,r7

xor r4,r1,r5

or r8, r1, r9

ALUIM Reg DM Reg

ALUIM Reg DM Reg

ALUIM Reg DM Reg

ALUIM Reg DM Reg

ALUIM Reg DM Reg


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 ALU pueda adquirir sus datos de entrada desde la salida de la ALU, odesde la salida de la memoria.

Ejemplo: Procesador Segmentado con Solución de Ries gos

Ejemplo: Riesgos de Datos por registros

�Se muestran las anticipaciones desde la salida de la ALU (del valor de $t1) y de la salida de la memoria (con el valor de $t1) hacia la entrada de la ALU de las instrucciones siguientes.

�También se muestra, el efecto anticipatorio, del uso de registros en base a latchs transparentes.

Condiciones para anticipar la salida de la ALU�Para anticipar la salida de la ALU usando muxes, debe

escribirse la salida de la ALU 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ónuna 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).

Como anticipar la salida de la ALU�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 */

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 estaen etapa operaciones

Ejemplo: Riesgos de Datos

Instr.

Order

lw $t1,0($t2)

sw $t1,0($t3)

addi $t6,$t1,$t3

ori $t10,$t9,$t11

ori $t8, $t1, $t9

ALUIM Reg DM Reg

ALUIM Reg DM Reg

ALUIM Reg DM Reg

ALUIM Reg DM Reg

ALUIM Reg DM Reg


Ejemplo: Riesgos de Datos

Instr.

Order

lw $t1,0($t2)

sw $t1,0($t3)

addi $t6,$t1,$t3

ALUIM Reg DM Reg

ALUIM Reg DM Reg

ALUIM Reg DM Reg


� 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 */

RD

RD1

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)

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;

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;

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;

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.

Otras Estructuras de Pipeline son Posibles�Si se tiene una operación lenta de multiplicación?

�Dejar que tome dos ciclos

�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)

ALUIM Reg DM Reg

MUL

ALUIM Reg DM1 RegDM2

Alternativas de Pipelines�ARM7

�StrongARM-1

�XScale

ALUIM1 IM2 DM1 Reg

DM2

IM Reg EX

PC updateIM access

decodereg

access

ALU opDM accessshift/rotatecommit result

(write back)

ALUIM Reg DM Reg

Reg SHFT

PC updateBTB access

start IM access

IM access

decodereg 1 access

shift/rotatereg 2 access

ALU op

start DM accessexception

DM writereg write

ELO311 Estructuras de Computadores Digitales...

Documents

Transcript of ELO311 Estructuras de Computadores Digitales...