Estructura y Tecnología de Computadores
Examen parcial
Tema 1: Sistemas Digitales Circuitos Combinacionales Tema 2: Sistemas Digitales Circuitos Secuenciales Tema 4: Diseño de un microprocesador
20 de marzo de 2012
DNI: Nombre:
Apellidos:
Instrucciones:
No se dará por válida ninguna respuesta que no contenga el desarrollo de la solución paso a paso y correctamente explicado.
La puntuación máxima de cada ejercicio aparece entre paréntesis. Responda a las preguntas en bolígrafo.
1. (4 puntos) Se quiere diseñar un circuito secuencial síncrono con una variable de entradaX
y una salidaZ que debe valer 1 cuando el valor deX en los dos ciclos anteriores haya sido
distinto, y 0 en otro caso. El circuito debe ser activo en el anco descendente del reloj.
Z X
Reloj
a) (1 punto) Complete el siguiente cronograma del circuito pedido:
Reloj X Z
b) (1 puntos) Dibuje un autómata nito determinista que modele el comportamiento del circuito. c) (2 puntos) Implemente el circuito utilizando biestables tipo T y puertas NAND.
2. (3 puntos) Calcule cuánto tiempo tardará en ejecutarse el progra-ma que se muestra a en el cuadro de la derecha en un procesador multiciclo como el visto en clase suponiendo que las latencias de sus unidades funcionales son:
Unidad de memoria: 30 ns. ALU: 12 ns.
Banco de registros (lectura o escritura): 20 ns.
A la hora de resolver el ejercicio, para las instrucciones que no estu-vieran presentes en el modelo original del procesador visto en clase suponga que tardan 4 ciclos en ejecutarse si son aritmético-lógicas o de desplazamiento. Además, tenga en cuenta que algunas instruccio-nes de ensamblador pueden ser realmente pseudoinstruccioinstruccio-nes que se implementen con una o más instrucciones reales distintas.
1 li $t0, 0x10010000
2 li $t1, 0x1001AB00
3 move $t2, $zero
4 li $t4, 29
5 loop: sll $t3, $t2, 2
6 add $t3, $t0, $t3
7 lw $t3, 0($t3)
8 sw $t3, 0($t1)
9 beq $t2, $t4, fin
10 addi $t2, $t2, 1
11 addi $t3, $t3, 4
12 j loop
13 fin: ...
3. (3 puntos) Utilizando la metodología descrita en los apuntes para la inclusión de nuevas instrucciones en el esquema de implementación multiciclo, realice las fases de análisis y diseño de la siguiente instrucción:
jalr $a: salta a la dirección contenida en el registro $a y guarda la dirección de retorno (dirección de la instrucción siguiente al jalr) en el registro $ra ($31).
Soluciones
Ejercicio 1
Apartado a
Reloj X Z
Apartado b
Para generar la salida en el ciclo actual, el autómata necesita recordar el valor de la entradaX en los dos últimos
ciclos. Utilizaremos los siguientes estados:
Estado Signicado
Est0 Se han recibido dos ceros en los últimos 2 ciclos.
Est1 Se ha recibido un uno en el último ciclo y un cero en el anterior.
Est2 Se ha recibido un cero en el último ciclo y un uno en el anterior.
Est3 Se han recibido dos unos en los últimos 2 ciclos.
Usando esos estados, el autómata sería:
Est0/
Z= 0
Est1/
Z= 1
Est2/
Z= 1
Est3/
Z= 0
X= 1
X
=
0
X= 0
X
=1
X
= 0
X
=
1
X
=0
X
= 1
Apartado c
Estado actual Entrada (X) Estado Siguiente
Est0 0 Est0
Est0 1 Est1
Est1 0 Est2
Est1 1 Est3
Est2 0 Est0
Est2 1 Est1
Est3 0 Est2
Est3 1 Est3
Tenemos cuatro estados, por lo que necesitamos 2 ip-ops para codicarlos (Q0 yQ1). Utilizaremos la siguiente
codicación:
Estado Codicación (Q1Q0)
Est0 00
Est1 01
Est2 10
Est3 11
Si reescribimos la tabla de transiciones utilizando la codicación anterior, queda de la siguiente manera:
Estado actual (Q1Q0) Entrada (X) Estado Siguiente (Q∗1Q∗0)
00 0 00
00 1 01
01 0 10
01 1 11
10 0 00
10 1 01
11 0 10
11 1 11
Y tabla de verdad de la función de salida sería:
Estado actual (Q1Q0) Salida (Z)
00 0
01 1
10 1
11 0
Debemos calcular las entradas de excitación de los biestables teniendo en cuenta que los que debemos usar son de tipo T, por lo que usaremos la siguiente tabla:
Q→Q∗ T
0→0 0
0→1 1
1→0 1
1→1 0
Si extendemos la tabla de transiciones anterior para mostrar también las entradas de excitación, quedaría:
Estado actual Entrada Estado Siguiente Entradas de excitación (Q1Q0) (X) (Q∗1Q∗0) (T1T0)
00 0 00 00
00 1 01 01
01 0 10 11
01 1 11 10
10 0 00 10
10 1 01 11
11 0 10 01
Con esto ya podemos simplicar las funciones de transición (T1 yT0) y la de salida (Z):
T1:
0
1 31 70 51 0
0 21 60 41 0
1
00 01 11 10
X
Q1Q0
T0:
1
1 30 70 51 0
0 21 61 40 0
1
00 01 11 10
X
Q1Q0
T1= ¯Q1Q0+Q1Q¯0 T0=Q0X¯+ ¯Q0X
Z:
1
1 30
0
0 21
0
1
0 1
Q1
Q0
Z= ¯Q1Q0+Q1Q¯0
Para realizar la implementación de las funciones anteriores con puertas NAND, las negamos dos veces y aplicamos la ley de De Morgan:
T1= ¯Q1X+ ¯Q1Q0+Q1Q¯0= ¯Q1X+ ¯Q1Q0+Q1Q¯0= ¯Q1X×Q¯1Q0×Q1Q¯0
T0=Q0X¯ + ¯Q0X =Q0X¯ + ¯Q0X =Q0X¯×Q¯0X
Z= ¯Q1Q0+Q1Q¯0= ¯Q1Q0+Q1Q¯0= ¯Q1Q0×Q1Q¯0
Con lo que el circuito resultante será:
T Q
Q
T Q
Q
X
Z
CLK
Ejercicio 2
El tiempo de ejecución del programa vendrá dado por la expresión:
Tejecución=Ninstrucciones×CP I×Tciclo=Nciclos×Tciclo
El tiempo de ciclo (Tciclo) está determinado por la unidad funcional más lenta, que en este caso es la memoria que
Para hallar el número total de ciclos necesarios para la ejecución del programa, tendremos que seguir la ejecución del mismo paso a paso y contar cuántas veces se ejecuta cada instrucción.
Habrá que tener en cuenta que la primera y la segunda instrucciones (li) son en realidad pseudoinstrucciones que se traducen con dos instrucciones de código máquina (un lui y un ori). Las instrucciones de las líneas 3 y 4 (move y li) son también pseudoinstrucciones pero se traducen con una sola instrucicón cada una (add o addi).
El código tiene un bucle que va desde la línea 5 a la 12 del cual se sale cuando la condición que se comprueba en la línea 9 es verdadera (si $t2 es igual a $t4). $t4 se inicializa a 29 en la línea 4 y no se vuelve a modicar en el código. $t2 se inicializa a 0 en la línea 3 y se le suma uno en cada iteración en la línea 10 (que está después del beq). Por tanto, la línea 9 se ejecutará 30 veces (para los valores de $t2 del 0 al 29). Es decir, el código copia 30 palabras de la dirección 0x10010000 a la 0x1001AB00.
Por tanto:
Instrucción Ejecuciones Ciclos por ejecución Ciclos totales
1 li $t0, 0x10010000 1 8 8
2 li $t1, 0x1001AB00 1 8 8
3 move $t2, $zero 1 4 4
4 li $t4, 29 1 4 4
5 sll $t3, $t2, 2 30 4 120
6 add $t3, $t0, $t3 30 4 120
7 lw $t3, 0($t3) 30 5 150
8 sw $t3, 0($t1) 30 4 120
9 beq $t2, $t4, fin 30 3 90
10 addi $t2, $t2, 1 29 4 116
11 addi $t3, $t3, 4 29 4 116
12 j loop 29 3 87
Total: 943
Por tanto:
Tejecución =Nciclos×Tciclo= 943×30ns= 28,290µs
Ejercicio 3
Análisis:
1 - Especicación precisa de la semántica de la instrucción: La semántica de jalr $a es:
$29 ← PC + 4
PC ← $a
2 - Identicación del trabajo a realizar por cada unidad funcional principal:
• Banco de registros: ◦ Leer $a. ◦ Escribir $31.
• ALU: No hace nada (el cálculo de PC + 4 ya se realiza). • Memoria: No hace nada.
3 - Establecimiento del orden de precedencia entre las distintas tareas a realizar:
No hay dependencias entre las tareas, es decir: todas las tareas se pueden realizar simulatáneamente. Diseño:
1 - Denición de la codicación de la instrucción:
Esta instrucción necesita un operando en registro ($a). Además, también utliza el registro $31 ($ra) implí-citamente, y podemos aprovechar algún campo de la instrucción codicada para indexarlo. Por tanto, dado que solo se necesitan dos registros se podría utilizar tanto el forma I como el R. Elegiremos el formato R que es el que utiliza MIPS para codicar esta instrucción en la realidad.
jalr $a →
31 0
jalr
op 6 bits
a
rs 5 bits
0
rt 5 bits
31
rd 5 bits
0
shamt 5 bits
0
2 - División del trabajo en ciclos:
Ciclo 1 Ciclo 2 Ciclo 3
IR←Memoria[PC] A←Reg[rs] PC←A
PC←PC + 4 Reg[rd]←PC
3 - Extensión del camino de datos:
De las acciones especicadas en la tabla anterior, no podemos realizar las acciones del ciclo 3 con el camino de datos del procesador sin modicar. Para hacerlo posible tendremos que extenderlo de la siguiente manera: Para PC ← A: Añadir una nueva entrada al multiplexor controlado por la señal de control FuentePC
que esté conectada al registro A (en el que tenemos el contenido de $a). Dicho multiplexor tenía anteriormente 3 entradas conectadas, por lo que podemos añadir una más sin aumentar el tamaño de la señal de control FuentePC. La combinación 11 seleccionará la nueva entrada.
Para Reg[rd] ← PC: Añadir una nueva entrada al multiplexor controlado por la señal de control
MemA-Reg que esté conectada al contador de programa (PC). La señal de control pasará a tener dos bits en lugar de uno, y la combinación 10 seleccionará la nueva entrada.
4 - Extensión del control:
Habrá que añadir 1 nuevo estados al autómata de control original. El resultado se muestra a continuación:
1 IoD = 00 LeerMem = 1
EscrIR = 1 SelALUA = 0 SelALUB = 01
ALUOp = 00 FuentePC = 00
EscrPC = 1
2 SelALUA = 0 SelALUB = 11
ALUOp = 00 RegOri2 = 0
3b SelALUA = 1 SelALUB = 10
ALUOp = 00
3a SelALUA = 1 SelALUB = 00
ALUOp = 10
4a RegDest = 1 MemAReg = 00
EscrReg = 1
4c IoD = 01 EscrMem = 1
4b IoD = 01 LeerMem = 1
5 RegDest = 0 MemAReg = 01
EscrReg = 1 3c
SelALUA = 1 SelALUB = 00
ALUOp = 01 FuentePC = 01 EscrPCCond = 1 3d
FuentePC = 10 EscrPC = 1
3e EscrPC = 1 EscrReg = 1 FuentePC = 11
RegDest = 1 MemAReg = 10
op =
0 op = lw ó
op = sw
op
=
b
eq
op=
j op=
lw op = sw
op
=
