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 entrada X
X Z
y una salida Z que debe valer 1 cuando el valor de X en los dos ciclos anteriores haya sido
distinto, y 0 en otro caso. El circuito debe ser activo en el anco descendente del reloj.
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 1 li $t0, 0x10010000
multiciclo como el visto en clase suponiendo que las latencias de sus 2 li $t1, 0x1001AB00
unidades funcionales son: 3 move $t2, $zero
Unidad de memoria: 30 ns. 4 li $t4, 29
ALU: 12 ns. 5 loop: sll $t3, $t2, 2
6 add $t3, $t0, $t3
Banco de registros (lectura o escritura): 20 ns. 7 lw $t3, 0($t3)
A la hora de resolver el ejercicio, para las instrucciones que no estu- 8 sw $t3, 0($t1)
vieran presentes en el modelo original del procesador visto en clase 9 beq $t2, $t4, fin
suponga que tardan 4 ciclos en ejecutarse si son aritmético-lógicas o 10 addi $t2, $t2, 1
de desplazamiento. Además, tenga en cuenta que algunas instruccio- 11 addi $t3, $t3, 4
nes de ensamblador pueden ser realmente pseudoinstrucciones que 12 j loop
se implementen con una o más instrucciones reales distintas. 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).
Para que la solución del ejercicio se considere correcta, es importante que incluya claramente todos los pasos
correspondientes a las fases de análisis y diseño. Las modicaciones al camino de datos y la unidad de control
deberán estar explicadas por escrito. De forma complementaria, se pueden realizar modicaciones y anotaciones
sobre los diagramas originales para facilitar la explicación.
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 entrada X 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:

0
=
X

Est0 / X =1 Est1 /
Z =0 Z =1
1
=
X
X =0

X =1

X
=
0

Est3 / X =0 Est2 /
Z =0 Z =1
X
=
1

Apartado c
Del apartado anterior se obtiene que la función de transición del autómata queda denida por la siguiente tabla:

2
 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 y Q1 ). Utilizaremos la siguiente
codicación:
Estado Codicación (Q1 Q0 )
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 (Q1 Q0 ) Entrada (X ) Estado Siguiente (Q∗1 Q∗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 (Q1 Q0 ) 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

(Q1 Q0 ) (X ) (Q∗1 Q∗0 ) (T1 T0 )
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
11 1 11 00

3
 Con esto ya podemos simplicar las funciones de transición (T1 y T0 ) y la de salida (Z ):

Q1 Q0 Q1 Q0
00 01 11 10 00 01 11 10
   
0 0 1 0 1 0 0  1 1 0
0 2 6 4 0 2
 6 4
T1 : X T0 : X
1 0  1 0  1 1 1 0 0 1
1 3 7 5 1 3 7 5
T1 = Q̄1 Q0 + Q1 Q̄0 T0 = Q0 X̄ + Q̄0 X

Q0
0 1

0 0 1
2
0
Z: Q1
1 1 0
1
3
Z = Q̄1 Q0 + Q1 Q̄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 = Q̄1 X + Q̄1 Q0 + Q1 Q̄0 = Q̄1 X + Q̄1 Q0 + Q1 Q̄0 = Q̄1 X × Q̄1 Q0 × Q1 Q̄0

T0 = Q0 X̄ + Q̄0 X = Q0 X̄ + Q̄0 X = Q0 X̄ × Q̄0 X
Z = Q̄1 Q0 + Q1 Q̄0 = Q̄1 Q0 + Q1 Q̄0 = Q̄1 Q0 × Q1 Q̄0

Con lo que el circuito resultante será:

X

Z
T Q

T Q

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
tarda 30 ns.

4
 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 × 30 ns = 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.
31 0
jalr $a → jalr a 0 31 0 0
op 6 bits rs 5 bits rt 5 bits rd 5 bitsshamt 5 bitsfunc 6 bits

5
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:

3e
EscrPC = 1
EscrReg = 1
FuentePC = 11
RegDest = 1
MemAReg = 10
op = jalr

1
IoD = 00
LeerMem = 1 2 op = lw ó 3b
EscrIR = 1 SelALUA = 0 op = sw SelALUA = 1 op = sw 4c
SelALUA = 0 SelALUB = 11 IoD = 01
ALUOp = 00 SelALUB = 10
SelALUB = 01 ALUOp = 00 EscrMem = 1
ALUOp = 00 RegOri2 = 0
FuentePC = 00
EscrPC = 1 op op
j
op = beq

= = =
op 0 lw

3c
SelALUA = 1 3a
3d SelALUB = 00 SelALUA = 1 4b
FuentePC = 10 ALUOp = 01 SelALUB = 00 IoD = 01
EscrPC = 1 FuentePC = 01 ALUOp = 10 LeerMem = 1
EscrPCCond = 1

4a 5
RegDest = 1 RegDest = 0
MemAReg = 00 MemAReg = 01
EscrReg = 1 EscrReg = 1