ARQUITECTURA DE COMPUTADORES

Presentación del tema: "ARQUITECTURA DE COMPUTADORES"— Transcripción de la presentación:

1 ARQUITECTURA DE COMPUTADORES
Semestre A-2009 Clase 12

2 AGENDA 2do Examen Parcial: Martes 30/06/2009
Arquitectura MIPS de un solo ciclo El lenguaje ensamblador MIPS Ejercicios

3 Computador → Máquina de estado
Un computador es sólo una gran máquina de estados. Los registros, memoria cache, memoria RAM y discos duros guardan el estado. El procesador se mantiene leyendo y actualizando el estado, de acuerdo a las instrucciones de algún programa. Estado CPU

4 Memorias Resulta más sencillo utilizar dos memorias rápidas para almacenar datos e instrucciones de forma separada. A esta forma de distribución de la memoria se le conoce como Arquitectura Harvard. Debido a que se manejarán palabras de 32 bits, se podrán direccionar 230 palabras. Las lineas azules representan señales de control. MemRead y MemWrite deben colocarse en 1 si se va a leer o si se va a escribir a memoria, respectivamente. Read address Instruction memory [31-0] Read address Write data Data memory MemWrite MemRead

5 Búsqueda de instrucción (fetching)
El procesador se encuentra siempre en un lazo infinito, buscando instrucciones en memoria y ejecutándolas. El registro contador de programa o registro PC almacena la dirección de la instrucción en ejecución. Las instrucciones MIPS son todas de 4 bytes de largo: 32 bits. Es por ello, que el PC debe ser incrementado de 4 en 4 (Para leer la siguiente instrucción, en secuencia) Leer dirección Memoria de Instrucciones Instrucción [31-0] PC Add 4

6 Formato de instrucción R
Las instrucciones aritméticas registro a registro, utilizan el formato de instrucción R. op es el código de instrucción, y func especifica una operación aritmética particular. rs, rt y rd son los dos registros fuentes y el registro destino Un ejemplo de una instrucción y su codificación es: add $s4, $t1, $t2 op rs rt rd shamt func 6 bits 5 bits 000000 01001 01010 10100 00000 100000

7 Registros y ALUs Las instrucciones de formato de instrucción R, deben acceder a los registros y a la UAL. Nuestro Archivo de registros almacena 32 valores de 32 bits. Cada indicador de registro tiene 5 bits. Se puede leer de dos registros al mismo tiempo. RegWrite es 1 si se va a escribir en un registro Leer registro 1 registro 2 Escribir registro data data 2 data 1 Registros RegWrite ALUOp Función 000 and 001 or 010 add 110 sub 111 slt ALU ALUOp

8 Ejecución en el formato de instrucción R
1. Se lee una instrucción desde la memoria de instrucciones. 2. Los registros fuente, indicados por los campos rs y rt, se leen desde el archivo de registros. 3. La UAL realiza la operación correspondiente. 4. El resultado es guardado en el registro de destino, el cual es especificado por el campo rd de la instrucción. Leer registro 1 Leer registro 2 Escribir register data data 2 data 1 Registros RegWrite Resultado Zero ALU ALUOp Leer dirección Instrucción [31-0] I [ ] I [ ] Memoria de Instrucciones I [ ] op rs rt rd shamt func 31 26 21 16 11 6 5 0

9 Formato de instrucción I
Las instrucciones lw, sw y beq instructions utilizan el formato de instrucción I. rt es el destino para lw, pero una fuente para beq y sw. dirección es una constante, con signo, de 16 bits. Dos ejemplos: lw $t0, –4($sp) sw $a0, 16($sp) op rs rt dirección 6 bits 5 bits 16 bits 100011 11101 01000 101011 11101 00100

10 Acceso a datos de memoria
Para una instrucción como lw $t0, –4($sp), el registro base $sp es sumado a la constante de extensión de signo para obtener la dirección de memoria final. Esto significa que la UAL debe aceptar: o un operando de registro para una instrucción aritmética, o un operando inmediato con signo extendido para las instrucciones lw y sw. Agregaremos un multiplexor, controlado por ALUSrc, para seleccionar un operando de registro (0) o un operando constante (1). Leer dirección Escribir address data Memoria de Datos MemWrite MemRead 1 M u x MemToReg Memoria de Instrucciones Instrucción [31-0] I [15 - 0] I [ ] I [ ] I [ ] RegDst registro 1 registro 2 registro data 2 data 1 Registros RegWrite Signo extend ALUSrc Resultado Zero ALU ALUOp

11 Memoria de Instrucciones
De memoria a registro La entrada “Escribir data” del archivo de registros, tiene un problema similar. Debe ser capaz de guardar, ya sea la salida de la UAL, en una instrucción R; o el dato de memoria para una instrucción lw. Añadiremos un multiplexor, controlado por MemToReg, para escoger entre guardar el resultado de la UAL (0) o el dato de salida de memoria (1) para los registros. Leer dirección Escribir data Memoria de Datos MemWrite MemRead 1 M u x MemToReg Memoria de Instrucciones Instrucción [31-0] I [15 - 0] I [ ] I [ ] I [ ] RegDst registro 1 registro 2 registro data 2 data 1 Registros RegWrite Signo extend ALUSrc Resultado Zero ALU ALUOp

12 Memoria de Instrucciones
RegDst Una molestia final es el registro destino de lw, el cual se encuentra en rt, en lugar de en rd. Añadiremos un multiplexor adicional, controlado por RegDst, para seleccionar el registro destino, desde el campo de instrucción rt (0) o desde el campo rd (1). op rs rt dirección lw $rt, dirección($rs) Leer dirección Escribir data Memoria de Datos MemWrite MemRead 1 M u x MemToReg Memoria de Instrucciones Instrucción [31-0] I [15 - 0] I [ ] I [ ] I [ ] RegDst registro 1 registro 2 registro data 2 data 1 Registros RegWrite Signo extend ALUSrc Resultado Zero ALU ALUOp

13 Saltos Para las instrucciones de salto, la constante no es una dirección, sino un desplazamiento de instrucción desde el contador de programa actual, hasta la dirección deseada. beq $at, $0, Etiq add $v1, $v0, $0 add $v1, $v1, $v1 j Etiq Etiq: add $v1, $v0, $v0 La dirección destino Etiq está tres instrucciones después de beq, por lo que la codificación de la instrucción de salto tendrá como campo de dirección. Las instrucciones tienen 4 bytes de largo, por lo que el desplazamiento real es de 12 bytes. 000100 00001 00000 op rs rt address

14 Pasos al ejecutar beq 1. Buscar la instrucción (Fetch) en memoria, como por ejemplo: beq $at, $0, desplazamiento 2. Leer los registros fuente, $at y $0, desde el archivo de registros. 3. Comparar los valores, restándolos en la UAL. 4. Si la resta es 0, Los operandos fuente eran iguales y se debe cargar en el PC la dirección destino: PC (desplazamiento x 4). 5. Si la resta no es 0, no se debe ejecutar el salto, y el PC sólo debe ser actualizado a PC + 4 para buscar la siguiente instrucción en secuencia.

15 Memoria de Instrucciones
Hardware para saltos Necesitamos un segundo sumador, ya que la UAL está ocupada haciendo la resta para beq. 4 Shift left 2 PC Add M u x 1 PCSrc Leer dirección Escribir data Memoria de Datos MemWrite MemRead MemToReg Memoria de Instrucciones Instruction [31-0] I [15 - 0] I [ ] I [ ] I [ ] RegDst registro 1 registro 2 registro data 2 data 1 Registros RegWrite Signo extend ALUSrc Resultado Zero ALU ALUOp  PCSrc = 1 # salto a PC+4+(offset4)  PCSrc = 0 continúa a PC+4. Multiplicación constante por 4, para obtener el desplazamiento

16 El camino de datos final
4 Shift left 2 PC Add M u x 1 PCSrc Leer dirección Escribir data Memoria de Datos MemWrite MemRead MemToReg Memoria de Instrucciones Instrucción [31-0] I [15 - 0] I [ ] I [ ] I [ ] RegDst registro 1 registro 2 registro data 2 data 1 Registros RegWrite Signo extend ALUSrc Resultado Zero ALU ALUOp

17 Control La unidad de control es la responsable de darle valores a las señales de control para que cada instrucción se ejecute correctamente. La entrada de la unidad de control son los 32 bits de la instrucción. Su salida son los valores para las señales de control del camino de datos. La mayoría de las señales pueden ser generadas a partir, únicamente, del opcode, sin requerir el resto de bits de la instrucción.

18 Tabla de señales de control
Operacion RegDst RegWrite ALUSrc ALUOp MemWrite MemRead MemToReg add 1 010 sub 110 and 000 or 001 slt 111 lw sw X beq sw y beq son las únicas instrucciones que no escriben en registros. lw y sw son las únicas instrucciones que utilizan un campo constante. Ellas también dependen de la UAL para calcular la dirección de memoria efectiva. ALUOp para el formato R depende del campo de instrucciones func. La señal de control PCSrc (no listada) debe ser establecida si la instrucción es beq y la salida Zero de la UAL es 1.

19 Señales de control generales
La unidad de control requiere 13 bits de entrada. Seis bits del opcode de instrucción. Seis bits del campo de instrucción func. La salida Zero de la UAL. La unidad de control genera 10 bits de salida, correspondientes a las señales mencionadas en la lámina anterior. Leer dirección Memoria de Instrucciones Instrucción [31-0] Control I [ ] I [5 - 0] RegWrite ALUSrc ALUOp MemWrite MemRead MemToReg RegDst PCSrc Zero

20 Instrucciones aritméticas

21 Instrucciones lógicas

22 Instrucciones de transferencia de datos

23 Instrucciones de salto condicional

24 Instrucciones de salto incondicional

25 Ejemplo 1 Programa en C: Programa en ensamblador: int f, g = 3, h = 1;
int i = 4, j = 4; if (i==j) f=g+h; else f=g-h; Programa en ensamblador: addi $s1,$zero,3 addi $s2,$zero,1 addi $s3,$zero,4 addi $s4,$zero,4 bne $s3,$s4,Else add $t0,$s1,$s2 j Fin Else:sub $t0,$s1,$s2 Fin:

26 Ejemplo 2 Programa en C: Programa en ensamblador: int i = 0, j = 5;
while (vector[i]==j) i+=1; Programa en ensamblador: li $s1,0 li $s2,0 # vector en $s6=0x While: sll $t1,$s1,2 add $t1,$t1,$s6 lw $t2,0($t1) bne $t2,$s2,Fin addi $s1,$s1,1 j While Fin:

27 Ejemplo 3 Programa en C: Programa en ensamblador: x = 0;
for(int i=0;i<100;i++) { x = x+i; } Programa en ensamblador: li $s1,0 # i = 0 li $s2,0 # x = 0 For: slti $t0,$s1,100 beq $t0,$zero,Fin add $s2,$s2,$s1 addi $s1,$s1,1 j For Fin:

28 Tarea Realizar un programa en lenguaje ensamblador MIPS, que calcule el factorial de un número (De manera no recursiva). Realizar un programa en lenguaje ensamblador MIPS, que calcule la multiplicación de dos números a través de sumas sucesivas.