ELO311 Estructuras de Computadores Digitales. Diseño de un Procesador Multiciclo

ELO311 Estructuras 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.

Procesador Multiciclo 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

Procesador Multiciclo 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.

Procesador Multiciclo En cada canto activo del reloj se pasa a un estado diferente (se captura el estado en los registros). En cada estado pueden activarse las señales de control que se requieran (salidas de redes combinacionales alimentadas 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.

Procesador Multiciclo 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.

Procesador Multiciclo 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 grupo está 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. A=R[rs], B=R[rt]; Unidad Registros. Lectura. S = sub(a, B); Unidad Operaciones. R[rd] = S. Unidad Registros. Escritura.

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. A=R[rs], B=R[rt]; Unidad Registros. Lectura. S = slt(a, B); Unidad Operaciones. R[rd] = S. Unidad Registros. Escritura. 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.

Transferencias Físicas de Datos (cont) LOAD: R[rt] <= MEM[ R[rs] + sign_ext(inm16)]; PC <= PC + 4 IR = MemInst[PC], PC=PC+4; Unidad Instrucción. A = R[rs]; Unidad Registros. Lectura. 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. A=R[rs], B=R[rt]; Unidad Registros. Lectura. S = add( A, sign_ext(inm16)); Unidad Operaciones. MemDat[S] = B. Unidad Memoria Datos.

Transferencias Físicas de Datos (cont) 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. WEa, WEb ; Unidad Registros. Lectura. 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. WEa, WEb ; Unidad Registros. Lectura. AluSrc = "busb", AluCtr = slt, WEs ; Unidad Operaciones. RegDst = "rd", Memtoreg="alu", RegWr. Unidad Registros. Escritura. 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.

Señales de control (cont) LOAD: R[rt] <= MEM[ R[rs] + sign_ext(inm16)]; PC <= PC + 4 npc_sel = +4, WEpc, WEir ; Unidad Instrucción. WEa ; Unidad Registros. Lectura. 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.

Señales de control (cont) 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 promedio de CPI (ciclos por instrucción) para la mezcla es de 3,98.

Comportamiento del Procesador Multiciclo (cont) 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.

Comportamiento del Procesador Multiciclo (cont) 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 npcsel0 npcsel1 PC 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 npcsel0 npcsel1 Se muestra una arquitectura que comparte la memoria de datos con la de instrucciones. PC Para esto es necesario modificar la unidad de instrucción, sacando de ésta la memoria de instrucciones. IR

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, y grabarla en IR; o bien leer la dirección efectiva de la memoria apuntada por S, y grabar el dato en M. WE A WE B WE S 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. npcsel0 npcsel1 PC IR

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. 2 PC IR

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 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 = M[PC], PC = add(pc, +4); Unidad Instrucción, Operaciones. A=R[rs], B=R[rt]; Unidad Registros. Lectura. S = sub(a, B); Unidad Operaciones. R[rd] = S. Unidad Registros. Escritura.

Transferencias Físicas de Datos (cont) 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. A=R[rs], B=R[rt]; Unidad Registros. Lectura. S = slt(a, B); Unidad Operaciones. R[rd] = S. Unidad Registros. Escritura. ORI: R[rt] <= R[rs] + zero_ext(inm16); PC <= PC + 4 IR = M[PC], PC = add(pc, +4); Unidad Instrucción, Operaciones. A = R[rs]; Unidad Registros. Lectura. S = or(a, zero_ext(inm16) ); Unidad Operaciones. R[rt] = S. Unidad Registros. Escritura.

Transferencias Físicas de Datos (cont) LOAD: R[rt] <= MEM[ R[rs] + sign_ext(inm16)]; PC <= PC + 4 IR = M[PC], PC = add(pc, +4); Unidad Instrucción, Operaciones. A = R[rs]; Unidad Registros. Lectura. 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. A=R[rs], B=R[rt]; Unidad Registros. Lectura. S = add( A, sign_ext(inm16)); Unidad Operaciones. M[S] = B. Unidad Memoria Datos.

Transferencias Físicas de Datos (cont) 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 ; WEa, WEb ; Unidad Registros. Lectura. 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, WEpc, MemRd, WEir ; WEa, WEb ; Unidad Registros. Lectura. AluSrcA = "busa, AluSrcB = "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 = alu, AluSrcA = PC, AluSrcB= +4, AluCtr= add, WEpc, MemRd, WEir ; WEa, WEb ; Unidad Registros. Lectura. AluSrcA = "busa, AluSrcB = "busb", AluCtr = slt, WEs ; Unidad Operaciones. RegDst = "rd", Memtoreg="alu", RegWr. Unidad Registros. Escritura. ORI: R[rt] <= R[rs] + zero_ext(inm16); PC <= PC + 4 npc_sel = alu, AluSrcA = PC, AluSrcB= +4, AluCtr= add, WEpc, MemRd, WEir ; WEa ; Unidad Registros. Lectura. AluSrcA = "busa, AluSrcB = "Op32", ExtOp = zero, AluCtr = ori, WEs ; Unidad Operaciones. RegDst = "rt", Memtoreg="alu", RegWr. Unidad Registros. Escritura.

Señales de control (cont) LOAD: R[rt] <= MEM[ R[rs] + sign_ext(inm16)]; PC <= PC + 4 npc_sel = alu, AluSrcA = PC, AluSrcB= +4, AluCtr= add, WEpc, MemRd, WEir ; WEa ; Unidad Registros. Lectura. 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 ; WEa, WEb ; Unidad Registros. Lectura. AluSrcA = "busa, AluSrcB = "Op32", ExtOp = sign, AluCtr = add, WEs ; Unidad Operaciones. MemWr. Unidad Memoria Datos.

Señales de control (cont) 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 ; WEa, WEb ; Unidad Registros. Lectura. 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 deben estar 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 estados para 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 wait proveniente de la memoria. Ej.: if (Wait) {WEir = 0; WEpc = 0;} else {WEir = 1; WEpc = 1;} WE IR WE PC

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, larus@cs.wisc.edu. # 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 el modelo 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 combinacionales mí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)

Diseño de la Unidad de Control: Microprog. (cont) 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 estados ocurren 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 secuenciador mediante muxes, un sumador en uno y algunas redes combinacionales, que implementan el contador con las funciones especiales.

Diseño de la Unidad de Control: Microprog. (cont) Las redes combinacionales que determinan la próxima microinstrucció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.

Diseño de la Unidad de Control: Microprog. (cont) 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 de control. 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.

Diseño de la Unidad de Control: Microprog. (cont) 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 programa en 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.

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.

Diseño del Microprograma: Transferencias (cont) 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.

Diseño del Microprograma: Transferencias (cont) 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 microprograman siete instrucciones, se tiene:

Diseño del Microprograma: Transferencias (cont) 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:

Diseño del Microprograma: Transferencias (cont) 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))

Diseño del Microprograma: Transferencias (cont) La siguiente tabla muestra los contenidos del microprograma Se aprecia el µcontrol y las µoperaciones que cambian el PC.

Diseño del Microprograma: Transferencias (cont) 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ón de 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 operaciones modificada 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, add: AluOut=add(PC, sign_ext(inm16)] *4), BR=AluOut, µpc = T0[OP]. AluOut = add(a, B), µpc = µpc +1; R[Rd] = AluOut, AluOut = add(a, B), µpc = 0. sub: ori: AluOut = sub(a, B), µpc = µpc +1; R[Rd] = AluOut, AluOut = sub(a, B), µpc = 0. 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ñales de 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.