CLASE 11

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

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.

REGISTROS MIPS Y MEMORIA

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

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

INSTRUCCIONES ARITMETICO-LOGICAS Uso de la instrucción: add dest, 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).

INSTRUCCIONES DE TRANSFERENCIA DE DATOS Transfieren datos entre registros y memoria. Ojo: Los operandos aritmeticos 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)

EJEMPLO: CARGANDO UNA VARIABLE SIMPLE

EJEMPLO: CARGANDO UN ARRAY

Será tratado mas adelante 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

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

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. Register Memory Register Memory

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

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. ALTO NIVEL ENSAMBLADOR USO if bne beq bne rs, rt, label beq rs, rt, label goto j j label

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. INSTRUCCION SINTAXIS OPERACIÓN beq beq rs, rt, label Si (rs==rt) salta a la instrucción etiquetada con Label. FORMATO I bne bne rs, rt, label

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

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.

Dirección de destino de salto 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=32767 instrucciones a partir de la instrucción siguiente a la instrucción de salto. beq rs, rt, Label 4 rs rt Offset 16 bits opcode bne rs, rt, Label 5 rs rt Offset 16 bits opcode PC Add 32 offset 16 00 sign-extend from the low order 16 bits of the branch instruction branch destination address ? 4 Dirección de destino de salto

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 opcode Target address 6 bits 26 bits Ejemplo: j Label 2 Target address opcode

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 j Label 2 Target address opcode PC 4 32 26 00 from the low order 26 bits of the jump instruction

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 (noejecutada si i==j) Exit: ... El ensamblador calcula las direcciones correspondientes para crear el código de máquina

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; 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 Exit: 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: ...

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 rd se pone a 1 si el valor en el registro rs es menor que el valor en el registro rt De lo contrario, rd se pone a cero La instrucción es set on less than (slt) sigue el formato R rs rt rd 42 opcode shamt funct

INSTRUCCIONES DE CONTROL DE FLUJO La instrucción set on less unsigned es una variacion de la instrucción stl y funciona como se muestra a continuacion: sltu rd, 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

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 $zero para 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 igual que (less than or equal to) : ble $s1, $s2, Label Mayor que (greater than) : bgt $s1, $s2, Label Mayor o igual que (great than or equal to): bge $s1, $s2, Label

EJEMPLO: DESVIO SI MENOR QUE 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 j Fin # va para Fin Else: sub $s0, $s1, $s2 # f = g – h Fin: ...

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 lb rt, offset(rs) # Carga en los 8 LSBits de rt un byte lh rt, offset(rs) # Carga en los 16 LSBits de rt media palabra # El valor cargado es extendido en signo # a 32 bits en rt lbu rt, offset(rs) # Carga en los 8 LSBits de rt un byte lhu rt, offset(rs) # Carga en los 16 LSBits de rt media palabra # El valor cargado es extendido con 0’s sb rt, offset(rs) # Almacena en los 8 LSBits de la palabra en M. sh rt, offset(rs) # Almacena en los 16 LSBits de la palabra en M. # Los bits restantes de la palabra en memoria # no se modifican

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 upper immediate, 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

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

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