elo311 estructuras de computadores digitales diseño...

ELO311Estructuras de Computadores Digitales

Diseño de un Procesador Multiciclo

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

�material del curso anterior ELO311 del Prof. Leopoldo Silva

�www.wikipedia.org

Procesador Monociclo

�En el modelo del procesador monociclo el período del reloj se ajusta con la ruta crítica combinacional, que es la establecida por la instrucción más lenta en completar sus transferencias.

�Si existen instrucciones que demoran demasiado (e.g. las de punto flotante) la frecuencia del reloj debe ajustarse a la instrucción que mas tarda.

�En el modelo monociclo los recursos (e.g. Memoria, ALU, ...) deben utilizarse solo una vez por cada ciclo del reloj. Incluso esto causa que hay veces en que estos recursos deben duplicarse.

Procesador Multiciclo

�Estas razones llevan a pensar que las diferentes instrucciones puedan ser realizadas con varios ciclos (uno o mas ciclos) del reloj.

�Dependiendo de su complejidad unas podrían ser ejecutadas en pocos ciclos y otras en mas ciclos.

�Esto permite que las instrucciones tengan tiempos de ejecución diferentes, ya que emplean diferente número de ciclos de reloj.

Procesador Multiciclo (cont)

�Esto también permite realizar diseños de menor costo, al posibilitar el compartir los recursos y reutilizarlos durante la ejecución de una instrucción.

�Un recurso puede ser empleado más de una vez en la realización de una instrucción, siempre que se use en diferentes ciclos del reloj.

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

Procesador Monociclo vs Multiciclo

�Un esquema conceptual de la máquina monociclo, muestra una unidad combinacional con gran retardo de propagación, ubicada entre dos unidades de almacenamiento (memoria o registros): tp (tiempo propagación), ts (tiempo sumador IR), tr (tiempo registros)

Procesador Monociclo vs Multiciclo (cont)�Si se pudiera dividir la unidad combinacional, en dos

partes que supondremos con iguales tiempos de propagación, se tendrá el esquema siguiente.

�Se realiza el mismo trabajo, que en el esquema anterior, pero en dos ciclos más rápidos en lugar de uno más lento.

�Se agrega el tiempo de setup y hold pero en un mismo ciclo se pueden ocupar ambas etapas.

Procesador Monociclo vs Multiciclo (cont)

�Esto permite compartir un recurso; ya que se lo puede usar en diferentes ciclos de ejecución de una misma instrucción.

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


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


�En cada canto activo del reloj se pasa a un estadodiferente (se captura el estado en los registros).

�En cada estado pueden activarse las señales de controlque se requieran (salidas de redes combinacionalesalimentadas por los estados de los flip-flops de la unidad de control).

�Es decir las salidas de esta máquina secuencial deben estar asociadas al estado (modelo de Moore).

�La ejecución de cada instrucción puede visualizarse como un recorrido en el diagrama de estados; algunas instrucciones se ejecutarán pasando por pocos estados, otras tendrán recorridos más largos.


�El número de estados por los que pasa una instrucción son los ciclos de reloj que demora en realizarse, y esto se mide en CPI (ciclos por instrucción).

�El período del reloj debe ajustarse a la duración de la etapa más lenta, de este modo pueden realizarse todas las acciones y transferencias de cada etapa.

�Podría ajustarse el período del reloj de acuerdo al tiempo de la etapa más rápida.�Esto implica que el tiempo de las etapas seria un múltiplo de la

etapa más rápida, lo cual aumentaría el número de estados de la unidad de control, y complica su diseño.


2

Procesador Multiciclo: Unidad de Instrucción

� Se necesita el reg. IR, para guardar la instrucción previa ya que en el primer ciclo se calcula la dirección de la próxima instrucción y se escribe en el reg. PC.

� Al cambiar PC, cambia el bus de direcciones de la memoria de instrucciones, esto requiere almacenar la instrucción previa para tener los campos disponibles en el resto de la ejecución.

nPCSel0 nPCSel1

Transferencias Físicas de Datos

�Los grupos de micro operaciones que se realizan juntas en un ciclo de reloj, se separan por comas y el grupoestá terminado en un punto y coma.

�El término de instrucción se marca con un punto.

�ADD: R[rd] <= R[rs] + R[rt]; PC <= PC + 4�IR = MemInst[PC], PC = PC+4; Unidad Instrucción.

�A=R[rs], B=R[rt]; Unidad Registros. Lectura.

�S = add(A, B); Unidad Operaciones.

�R[rd] = S. Unidad Registros. Escritura.

�SUB: R[rd] <= R[rs] – R[rt]; PC <= PC + 4�IR = MemInst[PC], PC = PC+4; Unidad Instrucción.


�S = sub(A, B); Unidad Operaciones.


Transferencias Físicas de Datos (cont)

�SLT: if( R[rs] < R[rt]) R[rd] = 1; else R[rd] =0; PC <= PC + 4�IR = MemInst[PC], PC = PC+4; Unidad Instrucción.


�S = slt(A, B); Unidad Operaciones.


�ORI: R[rt] <= R[rs] + zero_ext(Inm16); PC <= PC + 4�IR = MemInst[PC], PC=PC+4; Unidad Instrucción.

�A = R[rs]; Unidad Registros. Lectura.

�S = or(A , zero_ext(Inm16) ); Unidad Operaciones.

�R[rt] = S. Unidad Registros. Escritura.


�LOAD : R[rt] <= MEM[ R[rs] + sign_ext(Inm16)]; PC <= PC + 4�IR = MemInst[PC], PC=PC+4; Unidad Instrucción.


�S = add( A , sign_ext(Inm16)); Unidad Operaciones.

�M = MemDat[S]; Unidad Memoria Datos.

�R[rt] = M. Unidad Registros. Escritura.

�STORE: MEM[ R[rs] + sign_ext(Inm16)] <= R[rt]; PC <= PC + 4�IR=MemInst[PC], PC=PC+4; Unidad Instrucción.


�S = add( A, sign_ext(Inm16)); Unidad Operaciones.

�MemDat[S] = B. Unidad Memoria Datos.


�BEQ: if ( R[rs] == R[rt] ) PC <= (PC +4) + sign_ext(Inm16)*4 else PC <= PC + 4�IR = MemInst[PC], PC=PC+4; Unidad Instrucción.

�A = R[rs], B = R[rt]; Unidad Registros. Lectura.

� if (Equal) Unidad Operaciones.

�PC = PC + sign_ext(Inm16)*4. Unidad Instrucción.

�JUMP: PC <= (PC +4)&0xF0000000+ add_26 *4�IR = MemInst[PC], PC=PC+4; Unidad Instrucción.

�PC = (PC)&0xF0000000 + add_26 *4. Unidad Instrucción.

Señales de control

�ADD: R[rd] <= R[rs] + R[rt]; PC <= PC + 4�nPC_sel = “+4”, WEpc , WEir ; Unidad Instrucción.

�WEa , WEb ; Unidad Registros. Lectura.

�AluSrc = "busB", AluCtr = “add”, WEs ; Unidad Operaciones.

�RegDst = "rd" , Memtoreg="alu", RegWr. Unidad Registros. Escritura.

�SUB: R[rd] <= R[rs] – R[rt]; PC <= PC + 4�nPC_sel = “+4”, WEpc , WEir ; Unidad Instrucción.


�AluSrc = "busB", AluCtr = “sub”, WEs ; Unidad Operaciones.

�RegDst = "rd", Memtoreg="alu", RegWr. Unidad Registros. Escritura.

Señales de control (cont)

�SLT: if( R[rs] < R[rt]) R[rd] = 1; else R[rd] =0; PC <= PC + 4�nPC_sel = “+4”, WEpc , WEir ; Unidad Instrucción.


�AluSrc = "busB", AluCtr = “slt”, WEs ; Unidad Operaciones.


�ORI: R[rt] <= R[rs] + zero_ext(Inm16); PC <= PC + 4�nPC_sel = “+4”, WEpc , WEir ; Unidad Instrucción.

�WEa ; Unidad Registros. Lectura.

�AluSrc = "Op32", ExtOp = “zero”, AluCtr = “ori”, WEs ; Unidad Operaciones.

�RegDst = "rt", Memtoreg="alu", RegWr. Unidad Registros. Escritura.


�LOAD : R[rt] <= MEM[ R[rs] + sign_ext(Inm16)]; PC <= PC + 4�nPC_sel = “+4”, WEpc , WEir ; Unidad Instrucción.


�AluSrc = "Op32", ExtOp = “sign”, AluCtr = “add”, WEs ; Unidad Operaciones.

�MemRd, WEm ; Unidad Memoria Datos.

�RegDst = "rt", Memtoreg = "mem", RegWr. Unidad Registros. Escritura.

�STORE: MEM[ R[rs] + sign_ext(Inm16)] <= R[rt]; PC <= PC + 4�nPC_sel = “+4”, WEpc , WEir ; Unidad Instrucción.

�WEa , WEb ; Unidad Registros.

�AluSrc = "Op32", ExtOp = “sign”, AluCtr = “add”, WEs ; Unidad Operaciones.

�MemWr. Unidad Memoria Datos.


�BEQ: if ( R[rs] == R[rt] ) PC <= (PC +4)+ sign_ext(Inm16)*4 else PC <= PC + 4�nPC_sel = “+4”, WEpc , WEir ; Unidad Instrucción.

�WEa , WEb ; Unidad Registros.

� if (Equal) { nPC_sel = “Br” , WEpc }. Unidad Instrucción.

�J: PC <= (PC +4)&0xF0000000+ add_26 *4�nPC_sel = “+4”, WEpc , WEir ; Unidad Instrucción.

�nPC_sel = “Jmp”, WEpc . Unidad Instrucción.

Comportamiento del Procesador Multiciclo

�Si definimos, en general:�TE = Tiempo de ejecución de un programa de prueba.

�C = Comportamiento Procesador = 1/ TE (a mayor tiempo, peor comportamiento)

�NI = Número de instrucciones del programa de prueba.

�CPI = Ciclos de reloj por instrucción (será diferente de uno en caso multiciclo)

�PC = Período del reloj.

�Se tiene que: TE = NI * CPI * PC

Comportamiento del Procesador Multiciclo (cont)

�Para el procesador monociclo con un período fijo de reloj (CPI=1), se tiene:

TE(monociclo) = NI*1*PCmono

�Se asume que el programa de prueba está constituido por la siguiente mezcla: 25% decargas, 11% de almacenamientos, 30% de sumas, 9% de restas, 4% de or inmediatos, 15% de bifurcaciones y 6% de saltos.

�TE(multiciclo) =NI(0,25*5+0,11*4+0,30*4+0,09*4+0,04*4+0,15*3+0,06*2)*PCmulticiclo=NI*3,98*PCmulticiclo

�Para multiciclo, puede considerarse que el valor promediode CPI (ciclos por instrucción) para la mezcla es de 3,98.


�Si la subdivisión en etapas, se realiza de tal modo que éstas requieran igual tiempo, podría modelarse cualitativamente que el período del reloj, en el caso monociclo, es cinco veces mayor que el requerido por el procesador multiciclo.

�La elección de tiempos iguales para las etapas tiende a minimizar el período del reloj requerido.

�La comparación:

�C(multiciclo)/ C(monociclo) = TE(monociclo) /TE(multiciclo) = PCmono/ (3,98*PCmulticiclo) = 5/3,98 = 1,26.

�indica que el procesador multiciclo es 1,26 veces más rápido que el monociclo.


�La comparación anterior no refleja bien las bondades del diseño multiciclo; en el caso del diseño del repertorio completo existen alrededor de 100 instrucciones y algunas de ellas demandan hasta 20 ciclos de reloj.

�En este caso el numerador aumentaría a 20 (monociclo) y el CPI promedio (multiciclo) no subiría apreciablemente si las instrucciones largas son poco frecuentes.

Compartir Recursos: Memoria

� El camino de datos anteriormente usado no comparte muchos recursos

� Puede tenerse sólo una unidad aritmética y compartirla para las operaciones de las unidades de instrucción y operación

� También puede obtenerse la condición de igualdad utilizando la misma unidad aritmética.

� También puede compartirse la memoria de instrucciones y de datos

� Se muestra una arquitectura que comparte la memoria de datos con la de instrucciones.

� Para esto es necesario modificar la unidad de instrucción, sacando de ésta la memoria de instrucciones.

PC

PC

IR

nPCSel0

nPCSel0 nPCSel1

nPCSel1

Compartir recursos: Memoria (cont)� Se ha agregado un mux controlado por MemCtr, que permite leer la

dirección apuntada por PC, que contiene la instrucción actual, ygrabarla en IR; o bien leer la dirección efectiva de la memoria apuntada por S, y grabar el dato en M.

WEB

WEA

WES

2 2

Compartir recursos: Memoria (cont)� El compartir el recurso, no cambia la velocidad de ejecución de las

instrucciones. Se ha sacado de la Unidad de Instrucción la memoria de programa.

� Se ilustra la descripción de las transferencias físicas y de control con la instrucción load y store word:

� LOAD : R[rt] <= MEM[ R[rs] + sign_ext(Inm16)]; PC <= PC + 4� IR = M[PC], PC=PC+4; Unidad Instrucción.�A = R[rs]; Unidad Registros. Lectura.�S = add( A , signext(Inm16)); Unidad Operaciones.�M = M[S]; Unidad Memoria Datos.�R[rt] = M. Unidad Registros. Escritura.

� STORE: MEM[ R[rs] + sign_ext(Inm16)] <= R[rt]; PC <= PC + 4� nPC_sel = “+4”, WEpc , MemRd, WEir , MemCtr=”Instrucciones”;

Unidad Instrucción.�WEa , WEb ; Unidad Registros. �AluSrc = "Op32", ExtOp = “sign”, AluCtr = “add”, WEs ; Unidad

Operaciones.�MemWr, MemCtr=”Datos”. Unidad Memoria Datos.

Compartir Recursos: ALU

� A continuación se muestra una arquitectura que además de compartir la memoria comparte la unidad aritmética.

� Para esto es necesario modificar la unidad de instrucción, sacando de ésta el sumador e introduciendo AluOut y S.

PC

IR

nPCSel1nPCSel0

Compartir Recursos: ALU

� Se han simplificado los recursos que emplea la unidad de instrucción. Sólo queda el circuito que forma la dirección de salto:

jump = PC &0xF0000000 + add_26 *4

� La formación de la dirección de salto requiere de el valor que esta almacenado en PC.

PC

IR

2

Compartir Recursos: ALU (cont)

� Para compartir la ALU, también se requiere modificar la Unidad de Operaciones. Permitiendo ingresar la salida del registro PC o el busA en el primer operando.

� También deben agregarse las entradas +4 y la dirección de bifurcación, como posibles segundos operandos.

� También se comparte la unidad extensora.

� Tomando el operando de 32 bits (Op32) y generando, por reordenamiento de las señales del bus, la señal:

branch = sign_ext(Inm16)*4

Transferencias Físicas de Datos

�Con estas modificaciones las transferencias físicas de datos pueden expresarse como:

�ADD: R[rd] <= R[rs] + R[rt]; PC <= PC + 4�IR = M[PC], PC = add(PC, +4); Unidad Instrucción, Operaciones


�S = add(A, B); Unidad Operaciones.


�SUB: R[rd] <= R[rs] – R[rt]; PC <= PC + 4�IR = M[PC], PC = add(PC, +4); Unidad Instrucción, Operaciones.


�S = sub(A, B); Unidad Operaciones.



�SLT: if( R[rs] < R[rt]) R[rd] = 1; else R[rd] =0; PC <= PC + 4�IR = M[PC], PC = add(PC, +4); Unidad Instrucción, Operaciones.


�S = slt(A, B); Unidad Operaciones.


�ORI: R[rt] <= R[rs] + zero_ext(Inm16); PC <= PC + 4�IR = M[PC], PC = add(PC, +4); Unidad Instrucción, Operaciones.


�S = or(A , zero_ext(Inm16) ); Unidad Operaciones.

�R[rt] = S. Unidad Registros. Escritura.


�LOAD : R[rt] <= MEM[ R[rs] + sign_ext(Inm16)]; PC <= PC + 4�IR = M[PC], PC = add(PC, +4); Unidad Instrucción, Operaciones.


�S = add( A , sign_ext(Inm16)); Unidad Operaciones.

�M = M[S]; Unidad Memoria Datos.

�R[rt] = M. Unidad Registros. Escritura.

�STORE: MEM[ R[rs] + sign_ext(Inm16)] <= R[rt]; PC <= PC + 4�IR = M[PC], PC = add(PC, +4); Unidad Instrucción, Operaciones.


�S = add( A, sign_ext(Inm16)); Unidad Operaciones.

�M[S] = B. Unidad Memoria Datos.


�BEQ: if ( R[rs] == R[rt] ) PC <= (PC +4) + sign_ext(Inm16)*4 else PC <= PC + 4�IR = M[PC], PC = add(PC, +4); Unidad Instrucción, Operaciones.

�A = R[rs], B = R[rt]; Unidad Registros. Lectura.

� if (Equal) PC = S Unidad Operaciones. Unidad Instrucción.

�JUMP: PC <= (PC +4)&0xF0000000+ add_26 *4�IR = M[PC], PC = add(PC, +4); Unidad Instrucción, Operaciones.

�PC = (PC)&0xF0000000 + add_26 *4. Unidad Instrucción.

Señales de control

�ADD: R[rd] <= R[rs] + R[rt]; PC <= PC + 4�nPC_sel = “alu”, AluSrcA = “PC”, AluSrcB=“+4”, AluCtr=“add”,

WEpc , MemRd, WEir ;


�AluSrcA = "busA“, AluSrcB = "busB", AluCtr = “add”, WEs ; Unidad Operaciones.

�RegDst = "rd" , Memtoreg="alu", RegWr. Unidad Registros. Escritura.

�SUB: R[rd] <= R[rs] – R[rt]; PC <= PC + 4�nPC_sel = “alu”, AluSrcA = “PC”, AluSrcB=“+4”, AluCtr=“add”,



�AluSrcA = "busA“, AluSrcB = "busB ", AluCtr = “sub”, WEs ; Unidad Operaciones.



�SLT: if( R[rs] < R[rt]) R[rd] = 1; else R[rd] =0; PC <= PC + 4�nPC_sel = “alu”, AluSrcA = “PC”, AluSrcB=“+4”, AluCtr=“add”,



�AluSrcA = "busA“, AluSrcB = "busB", AluCtr = “slt”, WEs ; Unidad Operaciones.


�ORI: R[rt] <= R[rs] + zero_ext(Inm16); PC <= PC + 4�nPC_sel = “alu”, AluSrcA = “PC”, AluSrcB=“+4”, AluCtr=“add”,



�AluSrcA = "busA“, AluSrcB = "Op32", ExtOp = “zero”, AluCtr = “ori”, WEs ; Unidad Operaciones.

�RegDst = "rt", Memtoreg="alu", RegWr. Unidad Registros. Escritura.


�LOAD : R[rt] <= MEM[ R[rs] + sign_ext(Inm16)]; PC <= PC + 4�nPC_sel = “alu”, AluSrcA = “PC”, AluSrcB=“+4”, AluCtr=“add”, WEpc ,

MemRd, WEir ;


�AluSrcA = "busA“, AluSrcB = "Op32", ExtOp = “sign”, AluCtr = “add”, WEs ; Unidad Operaciones.

�MemRd, WEm ; Unidad Memoria Datos.

�RegDst = "rt", Memtoreg = "mem", RegWr. Unidad Registros. Escritura.

�STORE: MEM[ R[rs] + sign_ext(Inm16)] <= R[rt]; PC <= PC + 4�nPC_sel = “alu”, AluSrcA = “PC”, AluSrcB=“+4”, AluCtr=“add”, WEpc ,

MemRd, WEir ;


�AluSrcA = "busA“, AluSrcB = "Op32", ExtOp = “sign”, AluCtr = “add”, WEs ; Unidad Operaciones.

�MemWr. Unidad Memoria Datos.


�BEQ: if ( R[rs] == R[rt] ) PC <= (PC +4)+ sign_ext(Inm16)*4 else PC <= PC + 4�nPC_sel = “alu”, AluSrcA = “PC”, AluSrcB=“+4”, AluCtr=“add”, WEpc

, MemRd, WEir ;


�AluSrcA = "busA“, AluSrcB = “branch”, AluCtr = “add”, WEs;

� if (Equal) { nPC_sel = “S” , WEpc }. Unidad Instrucción.

�J: PC <= (PC +4)&0xF0000000+ add_26 *4�nPC_sel = “alu”, AluSrcA = “PC”, AluSrcB=“+4”, AluCtr=“add”, WEpc

, MemRd , WEir ;

�nPC_sel = “Jmp”, WEpc . Unidad Instrucción.

Diseño de la unidad de control

�Se puede hacer un diagrama de estados a partir de las señales de control de cada etapa.

�Debido a que la primera serie de microoperaciones, para la etapa de búsqueda de instrucción, es igual para todas las instrucciones, se considera como el estado inicial.

�A partir de éste se colocan las secuencias de estados para generar las señales de control para cada etapa.

�En el interior de cada estado se colocan las salidas asociadas a ese estado.

�Después de la última microoperación de cada secuencia (cuando se encuentra un punto en la secuencia), debe volverse al estado inicial, para seguir ejecutando instrucciones.

Diseño de la unidad de control (cont)

�De acuerdo al valor de las entradas se cambia al estado siguiente, cuando ocurre el canto del reloj.

�Pueden aplicarse las técnicas tradicionales del diseño de máquinas secuenciales.

�Puede emplearse métodos para la reducción de estados. �Por ejemplo: el tercer estado de lw y sw son idénticos, y podrían

unirse en uno; en este caso las dos salidas de este estado debenestar rotuladas con el código de operación de lw y sw (esto debido a que el cuarto estado de éstas no es el mismo).

�También pueden unirse los cuartos estados de add y sub.

�Si se escribe en el registro B, se tendrá que el segundo estado de todas las instrucciones excepto el jump pueden unirse

�Si se hace esta reducción, las salidas de este segundo estado deben estar rotuladas con los códigos de operación de las instrucciones.

Diagrama de estados

�En el caso de diseñar un repertorio completo de instrucciones, no es práctico usar diagramas de estadospara describir cientos de estados con posibles centenares de secuencias diferentes (más aún si el tipo de repertorio es complejo y posee diversos modos de direccionamiento).

�Se verá más adelante la técnica de microprogramación, que básicamente consiste en diseñar la unidad de control como si fuera un computador en miniatura.

�El siguiente diagrama de estado muestra las diferentes secuencias de las señales de control para cada una de las instrucciones del simple repertorio hecho hasta ahora

Diagrama (cont)

Diagrama de estados: Asincrónicos (cont)

�En el diagrama de estados puede fácilmente incorporarse controles asincrónicos mediante ciclos de espera (wait).

�Algunas memorias después de transcurrido el tiempo de acceso activan una señal indicando este evento. El controlador debe adaptarse a memorias con diferentes tiempo de acceso empleando la señal (asincrónica) de waitproveniente de la memoria. �Ej.: if (Wait) {WEir = 0; WEpc = 0;} else {WEir = 1; WEpc = 1;}

WEPC

WEIR

Excepciones

� Las excepciones (e.g. división por zero) tienen que ser manejados ya que interrumpen el flujo de control normal

� Una excepción es una interrupción de ejecución no programada. Es una señal que avisa que ha ocurrido un evento que requiere ser atendido.

� El sistema debe estar programado para tomar una acción para manipular la excepción:� registrando la dirección de la instrucción que causó la excepción,

� salvando el estado del procesador,

� tomando una acción correctiva,

� recuperando el estado del procesador y

� devolviendo el control al programa que causó la excepción.

� La manipulación de excepciones disminuye la velocidad de procesamiento, ya que tiende a aumentar el CPI promedio.

� MIPS define que no debe ejecutarse la instrucción que causa la excepción.

Excepciones (cont)

�Los tipos de excepciones incluyen: interrupciones y traps.

�Interrupciones : Causadas por eventos externos.�Solicitación de dispositivo de entrada/salida�Asincrónicas con la ejecución del programa.�Deben ser manipuladas entre instrucciones.�Suspenden y reanudan la ejecución del programa.

�Traps : Causadas por eventos internos.�Condiciones de excepción (ej. overflow)�Errores (ej. paridad)�Fallas (ej. De página)�Llamados al Sistema Operativo�Intento de ejecutar instrucción ilegal.�Sincrónicas con la ejecución del programa�La instrucción puede ser reintentada o simulada y el programa

continúa o éste debe ser abortado.�Deben ser manejadas por un handler (manipulador).

Excepciones (cont)

�Formas de acceder al handler de excepciones:

�Los diferentes procesadores emplean mecanismos especiales para manipular la excepción.

�En el caso del procesador MIPS, cuando se produce una excepción se pasa a modo kernel, cambiando el valor de PC a una dirección fija.

�Entrada al handler: PC = 0x80000080 (MIPS)

�Otros procesadores emplean vectores o tablas de direcciones:�Tabla de direcciones. PC = M[base+causa] (8051)�Vectores de Interrupción. PC = base+causa

�Formas de salvar el estado/causa del error o excepción:�En el stack.�En registros especiales. EPC, BadVaddr, Status, Cause (MIPS)�Cambios de banco o registros sombreados.

Excepciones (cont)� MIPS agrega los siguientes recursos al camino de datos para excepciones:

� Registro EPC:�Registro 14 del coprocesador 0, es un registro de 32 bits que almacena la

dirección de la instrucción que ocasiona la excepción. Debe ser capaz de deshacer la suma PC = PC+4, ya que EPC debe apuntar a la instrucción que causa la excepción y no a la siguiente. Es decir: EPC = PC - 4.

� Registro Cause:� Registro 13 del coprocesador 0, de 32 bits. Almacena la causa de la excepción.

� Registro BadVAddr:� Registro 8 del coprocesador 0, contiene la dirección de la instrucción que efectuó un

direccionamiento ilegal.

� Registro Status:� Registro 12 del coprocesador 0, contiene las máscaras de interrupción y los bits de

habilitación.

� Es preciso modificar el camino de datos, además de agregar registros:� Se agrega una entrada al mux controlado por nPC_Sel, con la dirección fija del

manipulador de excepciones: 0x8000 0080

� Señales de control para escribir registros: EPC, Cause, BadVAddr, y Status.

� Estos registros están implementados en el simulador Spim, y descritos en el manual/apuntes.

Modos de Ejecución / Operación

�Proporcionar múltiples modos de ejecución (e.g. usuario versus kernel) facilita el desarrollo del sistema operativo, que es un programa especial que corre en modo privilegiado (modo kernel o system) que le permite tener acceso a todos los recursos del computador.

�Normalmente todos los procesos de entrada/salida son administrados por el sistema operativo.

�De este modo cada programa de usuario puede compartir recursos (archivos, discos, memoria, pantalla, red, etc.) en forma organizada.

�El manipulador de excepciones es parte del sistema operativo, en éste se programan las acciones en respuesta a eventos que ocurran mientras se ejecuta el programa del usuario.

Excepciones en la máquina de estados

�Se ilustran las modificaciones al diagrama de estados para tratar excepciones de dos tipos: overflow (rebalse) e instrucción ilegal.

�Overflow o rebalse aritmético:�Se emplea la condición generada por la ALU, para saltar a un estado

que genera excepción.

�Una instrucción indefinida o ilegal se detecta cuando no está definido el próximo estado para el código ilegal.�Se define un próximo estado, al que se pasa cuando el código de

operación es otro (diferente de lw, sw, j, beq, ori, tipo-R), en el cual se activan las microoperaciones para generar la excepción. La dirección ExcAdd es la del manipulador de excepciones.

Excepciones en la máquina de estados (cont)

SPIM Exception Handler# SPIM S20 MIPS simulator.

# The default trap handler for spim.

# Copyright (C) 1990-1995 James Larus, [email protected].

# Define the exception handling code. This must go first!

.kdata

__m1_: .asciiz " Exception "

__m2_: .asciiz " occurred and ignored\n"

__e0_: .asciiz " [Interrupt] "

__e1_: .asciiz ""

__e2_: .asciiz ""

__e3_: .asciiz ""

__e4_: .asciiz " [Unaligned address in inst/data fetch] "

__e5_: .asciiz " [Unaligned address in store] "

__e6_: .asciiz " [Bad address in text read] "

__e7_: .asciiz " [Bad address in data/stack read] "

__e8_: .asciiz " [Error in syscall] "

__e9_: .asciiz " [Breakpoint] "

__e10_: .asciiz " [Reserved instruction] "

__e11_: .asciiz ""

__e12_: .asciiz " [Arithmetic overflow] "

SPIM Exception Handler (cont)__e13_: .asciiz " [Inexact floating point result] "

__e14_: .asciiz " [Invalid floating point result] "

__e15_: .asciiz " [Divide by 0] "

__e16_: .asciiz " [Floating point overflow] "

__e17_: .asciiz " [Floating point underflow] “

excp: .word __e0_,__e1_,__e2_,__e3_,__e4_,__e5_,__e6_

.word __e7_,__e8_,__e9_,__e10_,__e11_,__e12_

.word __e13_,__e14_,__e15_,__e16_,__e17_

s1: .word 0 #para salvar registros de usuario.

s2: .word 0

.ktext 0x80000080 #ExcAdd

# Al entrar se pueden usar los registros k0 y k1, sin salvarlos, ya que el usuario

# no puede usar estos registros.

.set noat

move $k1, $at # Salva at ya que el manipulador usa macros.

.set at #Habilita uso de macros en modo kernel.

SPIM Exception Handler (cont)#El manipulador usa v0 y a0, los salva en memoria de datos del kernel.

#No usa el stack ya que la excepción puede ser una mala referencia al stack.

#Asume que no es confiable el valor de sp.

sw $v0, s1

sw $a0, s2 #Salva a0 y v0 en variables locales del kernel.

mfc0 $k0, $13 # Cause es el registro $13 del coprocesador 0

sgt $v0 , $k0, 0x44 # Ignora la excepción, mayor que causa 17.

bgtz $v0, ret

addu $0, $0, 0 # Equivale a un nop. Se ejecuta(delayed branch).

li $v0, 4 # syscall 4 (print_str con mensaje m1)

la $a0, __m1_

syscall

li $v0, 1 # syscall 1 (print_int)

srl $a0, $k0, 2 # Genera en a0 el número de la excepción,

syscall # y lo imprime.

li $v0, 4 # syscall 4 (print_str)

lw $a0, __excp($k0) #Accesa dirección mensaje de error.

syscall

SPIM Exception Handler (cont)bne $k0, 0x18, ok_pc # Causa = 6. Bad PC requires special checks

mfc0 $a0, $14 # a0 = EPC

and $a0, $a0, 0x3 # Is EPC word-aligned?

beq $a0, $zero, ok_pc

li $v0, 10 # Exit on really bad PC (out of text).

syscall

ok_pc:

li $v0, 4 # syscall 4 (print_str)

la $a0, __m2_

syscall

mtc0 $zero, $13 # Clear Cause register

ret: lw $v0, s1 # Recupera a0 y v0.

lw $a0, s2

mfc0 $k0, $14 # k0 = EPC

.set noat

move $at, $k1 # Restaura $at del usuario.

.set at # Habilita macros de usuario.

rfe # Return from exception handler

addiu $k0, $k0, 4 # Return to next instruction

jr $k0

SPIM Exception Handler (cont)

# Standard startup code.

#Invoke the routine main with no arguments.

.text

.globl __start

__start:

lw $a0, 0($sp) # argc

addiu $a1, $sp, 4 # argv

addiu $a2, $a1, 4 # envp

sll $v0, $a0, 2

addu $a2, $a2, $v0

jal main

li $v0, 10 # syscall 10 (exit)

syscall

SPIM Exception Handler (cont)

� Observaciones:

� a) La instrucción: sgt $v0, $k0, 0x44 # ignore interrupt exceptions es una macro, que expandida resulta:

ori $at, $zero, 0x44

slt $v0, $at, $k0 #coloca 1 en v0 si 0x44 < k0� 0x44 equivale al binario 1000100, con número de excepción binario 10001(ya

que los dos últimos son ceros). Es decir si la causa de excepción es mayor que 17 ignora la excepción.

� b) La macro: lw $a0, __excp($k0) #Accesa dirección mensaje de error.�Accesa al arreglo de punteros, que contienen los mensajes asociados a la

causa de la excepción. En k0 está la causa de la excepción, considerando que los dos bits menos significativos son ceros se tiene, por ejemplo, que cuando k0 tiene valor binario 11000, se tendrá la causa 6(110). Y se suma a la dirección dada por __excp el valor decimal 24(equivale a 11000); el cual equivale a 6*4. Es decir la sexta entrada con valor simbólico: __e6_.

� c) Los rótulos del kernel usan el símbolo underscore( _ ), de esta forma el ensamblador difícilmente puede tener conflicto con los símbolos de usuario.

� d) La instrucción rfe, restaura el registro de estado como estaba antes de la excepción y reanuda la ejecución en la instrucción siguiente a la que causó la excepción.

Diseño Unid. Control: Diagrama de estados

Diseño de la Unidad de Control: Clásico

�Diseño Clásico�A partir del diagrama de estados se generan ecuaciones lógicas para

determinar el próximo estado

�Las ecuaciones de salida son en función del estado (se emplea elmodelo de Moore, para máquinas secuenciales de estados finitos)

Diseño de la Unidad de Control: Clásico (cont)

�En cada estado se especifican los valores de las señales de control que determinan las transferencias entre registros.

�El cambio de estado ocurre en canto del reloj y la duración del reloj debe permitir la transferencia de la etapa más lenta.

�Del diagrama de estados se puede construir la siguiente tabla de verdad, que corresponde a la matriz de transiciones.

Diseño de la Unidad de Control: Clásico (cont)

�El diseño consiste en encontrar las funciones combinacionalesmínimas para:�Próximo estado = f1(Estado, Cod. Op., Funct)

�Señales de Control = f2(Estado, Cod. Op., Funct, Condiciones)

�La secuencia de estados depende sólo de la instrucción en ejecución

�La activación de algunas señales de control están condicionadas por los valores generados durante la ejecución.

Diseño de la Unidad de Control: Microprogramación

�Microprogramación�Se programan las transferencias entre registros y la secuencia en que

éstas deben efectuarse.

�Cada microinstrucción especifica el valor que deben tomar las señales de control, las funciones de la ALU, y cuál es la próxima microinstrucción.

�Una manera de implementar las funciones de próximo estado y las salidas es almacenar el estado en un registro (µPC), e implementar las funciones de próximo estado y las salidas en una ROM o en un dispositivo programable.

Diseño de la Unidad de Control: Microprog. (cont)

�Una representación de la información en la micromemoria, que se denomina microprograma es la siguiente:

�Denominamos microoperaciones a las señales de control que actúan sobre los recursos del camino de datos

�El secuenciador de microinstrucciones determina la siguiente microinstrucción a ejecutar:�señales que controlan µPC = (µControl PC, COp, Funct)


�La ejecución de una instrucción puede verse como la ejecución de una serie de microinstrucciones para activar las diferentes microoperaciones de una etapa del procesador

�Es necesario el registro µPC, el que mantiene estable el bus de direcciones de la micromemoria, entre ciclos del reloj.

Diseño de la Unidad de Control: Microprog.

�Una alternativa de diseño es emplear un contador, con las funciones sincrónicas de poner en cero, incrementar en uno y precargar un valor, para el registro µPC.

�Lo anterior observando que en el diagrama de estadosocurren frecuentes transiciones al estado inicial (clear, si se denomina con binario cero al estado inicial)

�En la figura siguiente se ilustra el diseño del secuenciadormediante muxes, un sumador en uno y algunas redes combinacionales, que implementan el contador con las funciones especiales.


�Las redes combinacionales que determinan la próximamicroinstrucción usando los bits de microcontrol y los códigos de operación (Cop, funct), suelen llamarse tablas de despacho.

�Con µPCsel = 0, se vuelve al estado inicial (búsqueda de instrucción o fetch); cuando es 1 se pasa a la microinstrucción siguiente; y cuando es 2 se determina la próxima microinstrucción usando la tabla de despacho.


�Se tienen dos modalidades de microprogramación:

�Microprogramación horizontal:�Se especifica un bit para cada punto del control del camino de datos.

�Se tiene control total del paralelismo del camino de datos, pero emplea gran cantidad de bits de microcódigo.

�Microprogramación vertical:�Se codifica el microcódigo usando campos en que se agrupan clases

de microoperaciones.

�Luego se decodifica localmente para generar todas las señales decontrol.

�Permite una mejor abstracción de la microprogramación, pero la decodificación puede hacer la máquina más lenta; debido a los niveles que deben recorrerse para la decodificación.


� Pueden especificarse diferentes formatos, por ejemplo uno para especificar transferencias y otro para especificar saltos.

� Ejemplo: asumiendo una longitud de palabra de micromemoria de 21 bits:

Transferencias:

Saltos:

� Hay solo dos formatos, por eso el campo código ocupa un bit.

� Compromiso: Espacio versus tiempo.

� Dependiendo de la estructura del camino de datos, algunas señales de control no se pueden activar simultáneamente

Diseño del Microprograma

�Existen dos modalidades de diseño del microprograma:

�Orientada a las transferencias:�Las microoperaciones son descritas por las transferencias físicas que

realizan.

�Orientada a las señales de control:�Microprogramación orientada a las señales de control utilizadas.

Diseño del Microprograma: Transferencias

�El microprograma se escribe en forma similar a un programaen un lenguaje de alto nivel.

�Cada línea, puede tener un rótulo que simboliza la microdirección, corresponde a una microinstrucción, que se realiza en un ciclo de reloj.

�Una microinstrucción es un secuencia de microoperaciones, separadas por comas.

�Las sentencias de control deben especificar cual será la próxima microinstrucción a realizar

�Pueden emplearse saltos a microdirecciones o activar funciones combinacionales (mediante las tablas de despacho) que determinan la próxima microdirección.

Diseño del Microprograma: Transferencias (cont)

�Ejemplo: El siguiente es el texto del microprograma que implementa el procesador multiciclo desarrollado anteriormente, pero con un segundo estado común para todas las instrucciones.

�Esto último implica que la instrucción jump se realizará en dos ciclos.

�Nótese que el estado siguiente al add y al sub se ha tratado como un solo estado equivalente (el ubicado en la microdirección writereg), lo cual requiere emplear otra tabla de despacho, ya que sólo puede existir un estado siguiente al estado 0011.

�En el siguiente diagrama la identificación del estado (e.g. 0000, 0001,..., 1100) es la microdirección.


fetch: IR = MemInst[PC], PC = PC+4, µPC = µPC +1;A=R[rs], B=R[rt], if(COp == J) PC = (PC)&0xF0000000+add_26*4, µPC = T0[OP];

add: S = add(A, B), µPC = T1[OP];

sub: S = sub(A, B), µPC = µPC +1;

writereg: R[rd] = S, µPC = 0.

ori: S = or(A, zero_ext(Inm16)), µPC = µPC +1;R[rt] = S, µPC = 0.

loadword: S = add(A, sign_ext(Inm16)), µPC = µPC +1;M = MemDat[S], µPC = µPC +1;R[rt] = M, µPC = 0.

storeword: S = add(A, sign_ext(Inm16)), µPC = µPC +1;MemDat[S] = B, µPC = 0.

beq: if (Equal) PC = PC + sign_ext(Inm16)] *4, µPC = 0.


�Si mediante las 12 líneas formadas por los buses Cop y Funct, formamos un decodificador de la instrucción, generando el bus OP, de tres bits, ya que en el ejemplo se microprogramansiete instrucciones, se tiene:


�La tabla de despacho 0, es descrito por el siguiente mapa de memoria, asumiendo la dirección 0000 para la primera microinstrucción que realiza la búsqueda de la instrucción.

�Incluye columnas con los mnemónicos de las instrucciones y con los nombres simbólicos de la micro direcciones:

�La tabla de despacho 1 (equivale a una constante), puede describirse según:


�Se definen tres microoperaciones para controlar la escritura en el registro PC. �La señal PCWR, que debe activarse para escritura incondicional en PC

�PCBEQ que se activa si la instrucción en ejecución es una bifurcación

�PCJ que se activa si la instrucción en curso es un salto incondicional.

�Las señales nPC_sel[1..0] seleccionan el contenido a escribir en el registro PC.

�La siguiente ecuación muestra cuando debe escribirse en el registro PC.�WEPC = PCWR | (PCBEQ & Equal) | (PCJ & (OP== j))


�La siguiente tabla muestra los contenidos del microprograma

�Se aprecia el µcontrol y las µoperaciones que cambian el PC.


�Se vuelve a dibujar un esquema parcial de la unidad de instrucción y un esquema, en base a compuertas, para la lógica que forma la señal de control que habilita la escritura en el registro PC.

nPCSel0 nPCSel1

Lógica Alambrada � Usar un dispositivo programable (eg. PLD) con salidas de

registro, para programar las funciones siguientes:� Próximo estado = F1(Estado, Cod. Op., Funct)

� Señales de Control = F2(Estado, Cod. Op., Funct, Condiciones)

� Con esta arquitectura, las realimentaciones del estado son internas al dispositivo.

� Este esquema se emplea para diseñar unidades de control en firmware, o de lógica alambrada.

� Diseño que resulta más rápido que la lectura de memorias del caso anterior.

Microsecuenciación� Una variante del esquema anterior (e.g. PLD) mediante

diagramas de estado, usa para registrar el estado un contador sincrónico con funciones (sincrónicas): de carga paralela, clear e incrementar.

� Se programa la función de próximo estado en función de estas señales. Este esquema se denomina de microsecuenciación y se emplea en diseños de la unidad de control

� Las funciones de las señales de control del contador son:� Cero: llevar al estado inicial.

� Inc: pasar al estado siguiente.

� Load: presetear un estado determinado

Microsecuenciación (cont)� Un esquema general de la arquitectura para diseñar

máquinas secuenciales, en base a un secuenciador, se ilustra a continuación:

Resumen de diseño de unidad de control� El siguiente esquema muestra las diversas relaciones que

existen y muestra las alternativas de diseño de la unidad de control.

Intro Segmentació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.

� Se verá más adelante las razones por las cuales las instrucciones deben durar aproximadamente lo mismo.

� Para lograr esto, basta en el diagrama de estados, agregar estados en los que no se activen controles.

Intro Segmentación (pipeline) (cont)

Intro Segmentación (pipeline) (cont)� Un esquema del control asociado a la etapa se muestra a

continuación.

Diseño del Microprograma: Texto Referencia

�Se desarrollará el método para el camino multiciclo propuesto en el texto de referencia, que se ilustra a continuación:

Diseño del Microprograma: Texto Referencia (cont)

� En este procesador� El camino de datos comparte la memoria para las instrucciones y los

datos

� Los cálculos de direcciones de la unidad de instrucción se realizan en la ALU

� Para calcular la condición de igualdad en las bifurcaciones se emplea la ALU (ésta genera la señal cero).

� En el primer ciclo del reloj � Se lee la memoria para obtener la instrucción a ejecutar, y al mismo

tiempo se emplea la unidad de operaciones para calcular la direcciónde la próxima instrucción (PC = PC + 4).

� En el segundo ciclo del reloj � Se decodifica la instrucción a ejecutar (en la unidad de control), al

mismo tiempo se leen los registros asociados a los campos Rs y Rt de la instrucción también se calcula empleando la unidad de operaciones la dirección de salto de la bifurcación (que se almacena en BR); y se genera la dirección de salto incondicional

Diseño del Microprograma: Texto Referencia (cont) � En el tercer ciclo del reloj

� Se ejecutan las operaciones inmediatas y aritméticas o se calcula la dirección en el caso de instrucciones de transferencias.

� En este procesador� Es necesario un registro adicional para almacenar la dirección de

bifurcación, se emplea BR con este propósito. Debe destacarse que se calcula en todos los casos dicha dirección, aunque la instrucción no sea una bifurcación.

� En caso de instrucción de salto, en el segundo ciclo se tiene decodificada la instrucción y se pueden activar las señales de control de PC, para grabar la dirección de salto que se denomina Jaddr, en el diagrama. Además, en este caso, se requiere que la próxima microinstrucción sea de búsqueda de próxima instrucción(fetch).

� De este modo el segundo estado será común para todas las instrucciones� Se leen los registros y se decodifica la instrucción, generándose las

señales de control, y mediante la activación de la tabla de despacho se puede seguir procesando las diferentes instrucciones.

Diseño del Microprograma: Texto Referencia (cont ) � A continuación se ilustran la forma de generar la dirección de

salto Jaddr, y un detalle de la unidad de operacionesmodificada para compartir la unidad aritmético lógica

� El camino de datos no almacena en registro la salida de la ALU, por esta razón deben sostenerse las entradas a la ALU

Diseño del Microprograma: Texto Referencia (cont) � fetch:

� IR = M[PC], AluOut=add(PC, 4), PC = AluOut, µPC = µPC +1;

� A=R[Rs], B=R[Rt],if(COp == J) PC = JAddr,

AluOut=add(PC, sign_ext(Inm16)] *4), BR=AluOut, µPC = T0[OP].

� add: � AluOut = add(A, B), µPC = µPC +1;

� R[Rd] = AluOut, AluOut = add(A, B), µPC = 0.

� sub: � AluOut = sub(A, B), µPC = µPC +1;

� R[Rd] = AluOut, AluOut = sub(A, B), µPC = 0.

� ori: � AluOut = or(A, zero_ext(Inm16)), µPC = µPC +1;

� R[Rt] = AluOut, AluOut = or(A, zero_ext(Inm16)), µPC = 0.

Diseño del Microprograma: Texto Referencia (cont) � loadword:

� AluOut = add(A, signext(Inm16)), µPC = µPC +1;

� Dout = M[AluOut], AluOut = add(A, signext(Inm16)), µPC = µPC +1;

� R[Rt] = Dout, AluOut = add(A, signext(Inm16)), µPC = 0.

� storeword: � AluOut = add(A, signext(Inm16)), µPC = µPC +1;

� M[AluOut] = B, AluOut = add(A, signext(Inm16) , µPC = 0.

� beq: AluOut= sub(A, B), if (Cero) PC = BR, µPC = 0.

� Notar: Son 14 microinstrucciones (separadas por ;).

Diseño del Microprograma: Texto Referencia (cont) � La siguiente tabla muestra

el contenido del microprograma, cada columna corresponde a una microinstrucción.

� En los renglones figuran los valores de las señalesde control.

Unidad de Control

Diseño del Microprograma: Texto Referencia (cont) � Para ejecutar el salto en dos ciclos se requiere agregar una

señal de control que se active cuando el código de operación es un salto incondicional.

� La tabla de verdad para la Tabla de Despacho 1, se ilustra a continuación.

� Las microdirecciones están en hexadecimal.

elo311 estructuras de computadores digitales diseño...

Documents