CLASE 11

1. CLASE 11

2. ¿QUE ES ARQUITECTURA DE COMPUTADORES? Arquitectura de la maquina Organización de la maquina

3. ARQUITECTURA VON-NEWMAN • Los programas y los datos se encuentran en memoria. • Para la ejecución de un programa las instrucciones y datos son llevadas a la CPU. • Los resultados se almacenan de nuevo en memoria. • La memoria esta unida a la CPU por medio de un bus de alto desempeño.

4. REGISTROS MIPS Y MEMORIA

5. ORGANIZACIÓN DE MEMORIA • Dos vistas de memoria: • bytes con direcciones 0, 1, 2, 3, …, . • palabras de 4 bytes (words) con direcciones 0, 4, 8, …, . • Ambos puntos de vista utilizan bytes como direcciones. • Las direcciones word deben ser multiplos de 4 (condición de alineamiento).

6. TIPOS DE INSTRUCCIONES MIPS Aritmetico – logicas Empleadas para manipular datos en registros. add $s1, $s2, $s3 $s1 = $s2 + $s3 or $s3, $s4, $s5 $s3 = $s4 OR $s5 Transferencia de datos Mueven los datos de registros desde/hacia memoria Serán tratadas mas adelante lw $s1, 100($s2) $s1 = Memory[$s2 + 100] sw $s1, 100($s2) Memory[$s2 + 100] = $s1 Salto Alteran el flujo de ejecución de un programa beq$s1, $s2, 25 if ($s1==$s2) PC = PC + 4 + 4*25

7. INSTRUCCIONES ARITMETICO-LOGICAS Uso de la instrucción: adddest, src1, src2 #dest= src1 + src2 sub dest, src1, src2 #dest= src1 - src2 and dest, src1, src2 #dest= src1 AND src2 • Características de la instrucción: • Siempre tendrá 3 operandos: Destino + 2 fuentes. • El orden de los operandos es fijo. • Los operandos son siempre registros de proposito general (GPR).

8. INSTRUCCIONES DE TRANSFERENCIA DE DATOS • Transfieren datos entre registros y memoria. • Ojo: Los operandosaritmeticos son registros, no memoria. Formado de la instruccion: lw$dest, offset($addr) # load word sw $src, offset($addr) # store word • Ejemplo: • codigo C: A[8] = h + A[8] • El codigo mips: El compilador asume que el valor de h esta asociado a $s2 y $s3 contiene la dirección base de A (A[0]). lw $t0, 32($s3) add $t0, $s2, $t0 sw $t0, 32($s3)

9. EJEMPLO: CARGANDO UNA VARIABLE SIMPLE

10. EJEMPLO: CARGANDO UN ARRAY

11. INSTRUCCIONES MIPS • Todas las instrucciones tienen exactamente 32 bits de ancho. • Diferentes formatos para diferentes propósitos. • Las similitudes en los formatos facilitan la implementación. Será tratado mas adelante

12. REPRESENTACION BINARIA DE UNA INSTRUCCION add $8, $17, $18 lw $9, 1200($8) == lw $t1, 1200($t0) Ver carta de referencia del MIPS

13. UTILIZANDO REGISTROS • Muchos programas tiene más variables que el número de registradores que tiene una máquina. • El compilador intenta mantener las variables más usadas en los registradores y coloca el resto en la memoria, utilizando loads y stores para mover los datos entre la memoria y los registradores. • Los compiladores tiene que utilizar los registradores de forma eficiente. Memory Register Memory Register

14. C/C++ statement Memory Processor + LW (Load Word) A C B LW (Load Word) S2 S1 S3 SW (Store Word) Assembly instructions B+C UTILIZANDO REGISTROS LW $S1, (address of B) LW $S2, (address of C) A = B + C; ADD $S3, $S2, $S1 SW $S3, (address of A) B C

15. INSTRUCCIONES DE CONTROL DE FLUJO • Muchos programas tiene más variables que el número de registradores que tiene una máquina. • Lo que distingue un computador de una calculadora simple es la habilidad de tomar decisiones. • Con base en la entrada y en los resultados computados, diferentes instrucciones son ejecutadas. • En lenguajes de alto nivel, una de las formas de tomar las decisiones es a través de las instrucciones if y goto. • En MIPS, tenemos dos instrucciones que actúan de manera similar las instrucciones que combinan if con goto.

16. SALTOS CONDICIONALES • Saltan a la instrucción etiquetada (label) si la condición es cierta de otra manera, continúan la ejecución secuencial. • Hay dos maneras de implementar saltos condicionales en lenguaje ensamblador. Para ello se emplean las instrucciones bne (branch if no equal) y beq (branch if equal). • Permiten reemplazar la instrucción if.

17. Memory ***.asm 4C000000 Assembled + Loaded XXXXXX My_Address: SALTOS CONDICIONALES – CALCULO DE LA DIRECCION ¿Cómo se calculan las direcciones? Programa almacenado (Modelo de Von Newman). My_Address:

18. SALTOS CONDICIONALES - CALCULO DE LA DIRECCION • Program counter (PC) • Registro que contiene la dirección de la instrucción a ejecutar • Este registro se actualiza (con el valor PC+4) en el ciclo de búsqueda (fetch) de la instrucción de tal manera que guarda la dirección de la siguiente instrucción.

19. ? SALTOS CONDICIONALES • Para calcular la dirección de destino de salto se emplea un registro (como en las instrucciones lw y sw), al que se suma el valor del offset de 16 bits. • Restringe la distancia del salto entre -215=-32768 y +215-1=32767instruccionesa partir de la instrucciónsiguiente a la instrucción de salto. beq rs, rt, Label from the low order 16 bits of the branch instruction bners, rt, Label 16 offset sign-extend 00 branch destination address 32 32 Add PC 32 32 Add Dirección de destino de salto 32 4 32 32

20. SALTOS INCONDICIONALES • El MIPS cuenta con una instrucción para desvio incondicional llamada instrucción de salto (jump). • Salta a la instrucción etiquetada con Label (goto). • La sintaxis es la mostrada a continuación: j Label • j label = goto label • Existe un formato para la instrucción de desvio, el formato tipo j FORMATO J Ejemplo: j Label

21. SALTOS INCONDICIONALES • Dirección de destino de salto • El campo Target address de 26 bits se usa para conformar un valor de 28 bits agregándole dos ceros en la parte baja. A esta cadena se concatenan, en su parte superior, los 4 bits más significativos del PC jLabel from the low order 26 bits of the jump instruction 26 00 4 32 PC 32

22. OPERACIONES LOGICAS Ejemplo: Compilación de la estructura if-then-else if(i==j) f=g+h; else f=g-h; Solución: Supongamos que el compilador asocia las variables f a j con los registros $s0 a $s4, respectivamente: bne$s3, $s4, Else#va a Else si i≠j add$s0, $s1, $s2 #f=g+h(no ejecutada si i≠j) j Exit #va a Exit Else: sub $s0, $s1, $s2#f=g-h (noejecutadasi i==j) Exit: ... El ensamblador calcula las direcciones correspondientes para crear el código de máquina

23. CICLOS • La Decisiones son importantes para escoger entre dos alternativas, y para iterar una serie de operaciones (loop). • Usamos las mismas instrucciones de ensamblador para las dos situaciones. • Todo depende de donde colocamos el rótulo (label) para el cual saltaremos. Loop: Ejemplo: Compilación de un bucle while while (save[i]==k) i+=1; Exit: Solución: Supongamos que el compilador asocia las variables i y k con los registros $s3 y $s5, y la base del vector save está en $s6 Loop: sll$t1, $s3, 2 # reg. temp. $t1=4*i add$t1, $t1, $s6 # $t1 = dirección save[i] lw$t0, 0($t1) # reg. temp. $t0 = save[i] bne$t0, $s5, Exit# va a Exit si save[i] ≠ k addi$s3, $s3, 1 # i = i+1 j Loop # va a Loop Exit: ...

24. INSTRUCCIONES DE CONTROL DE FLUJO • Las pruebas de igualdad y desigualdad son muy comunes (beq, bne) • También es útil saber si una variable es menor que otra (como en el caso de un bucle que prueba el índice de iteración) • La instrucción MIPS que lo hace es set on less than slt rd, rs, rt • Significado: • El registro rdse pone a 1 si el valor en el registro rses menor que el valor en el registro rt • De lo contrario, rdse pone a cero • La instrucción es set on less than (slt) sigue el formato R

25. INSTRUCCIONES DE CONTROL DE FLUJO • La instrucción set on less unsignedes una variacion de la instrucción stl y funciona como se muestra a continuacion: slturd, rs, rt # if (rs < rt) # rt = 1; # else #rt = 0; • Como las comparaciones con valores constantes son muy comunes, existe una versión de la instrucción set on less than con direccionamiento inmediato slti$t0, $s2, constant # if (rs<constant) # rt = 1; # else #rt = 0; • También existe sltiu

26. INSTRUCCIONES DE CONTROL DE FLUJO • Para comparar con cero: emplear registro $zero • El registro $zero(registro 0) tiene su valor fijado en cero (SIEMPRE). • No hay instrucciones MIPS de salto con condiciones <, ≤, >, ≥ porque harían más complejo el HW • Demandarían aumentar el ciclo de reloj (penalizando todas las instrucciones) • Compromiso de diseño: incluir sólo beq y bne, los casos más comunes. • Un compilador del MIPS emplea las instrucciones slt, beq y bne, además del registro $zeropara crear otras estructuras condicionales. • Menor que (less than): blt $s1, $s2, Label slt$at, $s1, $s2 #Lleva 1 a $at si$s1<$s2 bne$at, $zero, Label … … Label: … • Menor o igualque (less than or equal to) : ble$s1, $s2, Label • Mayor que (greater than) : bgt$s1, $s2, Label • Mayor o igualque (great than or equal to): bge$s1, $s2, Label

27. EJEMPLO: DESVIO SI MENOR QUE Ejemplo: Compilación de la estructura if-then-else if(i<j) f=g+h; else f=g-h; Else: Fin: Solución: Supongamos que el compilador asocia las variables f a j con los registros $s0 a $s4, respectivamente: slt$t0, $s0, $s1 # $t0 = (i < j)? beq $t0, cero, Else # va para else si i >= j add $s0, $s1, $s2 # f = g + h jFin # va para Fin Else: sub $s0, $s1, $s2 # f = g – h Fin: ...

28. TRANSFERENCIAS ENTRE BYTES Y MEDIAS PALABRAS (HALFWORDS) • Además de las instrucciones para mover palabras (lw y sw) el MIPS posee instrucciones para mover bytes y medias palabras. • Útiles para programas de procesamiento de texto • lbrt, offset(rs) # Carga en los 8 LSBits de rt un byte • lhrt, offset(rs) # Carga en los 16 LSBits de rt media palabra • # El valor cargadoesextendido en signo • # a 32 bits en rt • lburt, offset(rs) # Carga en los 8 LSBits de rt un byte • lhurt, offset(rs) # Carga en los 16 LSBits de rt media palabra • # El valor cargadoesextendido con 0’s • # a 32 bits en rt • sbrt, offset(rs) # Almacena en los 8 LSBits de la palabra en M. • shrt, offset(rs) # Almacena en los 16 LSBits de la palabra en M. • # Los bits restantes de la palabra en memoria • # no se modifican

29. OPERANDOS INMEDIATOS DE 32 BITS • Algunas veces las constantes no se pueden representar en el campo de 16 bits del formato I. • MIPS incluye una instrucción (load upperimmediate, lui) para cargar los 16 bits superiores de una constante en un registro, permitiendo que otra instrucción posterior ajuste los 16 bits inferiores de la constante de 32 bits. lui $t0, 0xAAAA 15 0 8 10101010101010102 10101010101010102 00000000000000002 ori $t0, $t0, 0xFFFF 00000000000000002 11111111111111112 10101010101010102 11111111111111112

30. SALTOS CONDICIONALES DE MAYOR ALCANCE • ¿Qué pasa si el destino del salto está más allá de lo que permiten 16 bits? • Dado un salto condicionado por la igualdad de los registros $s0 y $s1 • beq $s0, $s1, L1 • … • … • L1: … • Para lograr un salto de mayor alcance, se introduce un salto incondicional (jump) al destino del salto inicial, y se invierte la condición: • bne $s0, $s1, L2 • j L1 • L2: … • … • L1: …

31. REFERENCIAS • http://microe.udea.edu.co/~farivera/docencia.html • http://arch.eece.maine.edu/ece473/index.php/Lectures • http://inst.eecs.berkeley.edu/~cs61c/sp11/labs/05/ • http://inst.eecs.berkeley.edu/~cs61c/sp11/labs/06/ • http://cs.wellesley.edu/~cs240/ • http://www.ccs.neu.edu/course/csu380jc/calendar.html • http://logos.cs.uic.edu/366/notes/mips%20quick%20tutorial.htm • http://www.utdallas.edu/~dodge/EE2310/ • http://146.163.146.170/CS312/CS312.html • http://courses.missouristate.edu/KenVollmar/MARS/index.htm • http://www.ece.eng.wayne.edu/~gchen/ece4680/lecture-notes/lecture-notes.html • http://www.ece.cmu.edu/~jhoe/course/ece447/handouts/ • Computer organization and design. The hardware/software interface, 3rd ed., Chapter 2. D. Patterson and J. Hennessy. Morgan Kaufmann Publishers