Circuitos Digitales II y Laboratorio Fundamentos de Arquitectura de Computadores

Departamento de Ingeniería Electrónica Facultad de Ingeniería Circuitos Digitales II y Laboratorio Fundamentos de Arquitectura de Computadores Unidad 3: MIPS ISA Prof. Felipe Cabarcas cabarcas@udea.edu.co ❿1

Recordando de la primera unidad Arquitectura de Computadores >> ISAs y RTL La arquitectura de Computadores es transformada por la tecnología y las aplicaciones La historia provee lecciones para el futuro Los primero 130 años de AC, desde Babbage a IBM 360 Transformación desde las calculadoras (sin condicionales) a máquinas totalmente programables Rápidos cambios comenzaron en la Segunda guerra mundial (mediados de los años 40), pasaron de procesadores electromecánicos a solo electrónicos El costo del desarrollo del software se volvió un gran limitante de las arquitecturas (necesidad de compatibilidad) El IBM 360 introduce la noción de familia de máquinas ejecutar el mismo ISA pero diferentes implementaciones Seis máquinas diferentes lanzadas el mismo día (Abril 7, 1964) ❿2

Implementación inicial del IBM 360 Modelo 30... Modelo 70 Almacenamiento 8K - 64 KB 256K - 512 KB Bus de datos (datapath) 8-bit 64-bit Retardo circuitos 30 nsec/nivel 5 nsec/nivel Memoria local Memoria principal Reg. de Transistores Control Memoria Solo lectura 1µsec Circuitos La arquitectura del conjunto de instrucciones (ISA) del IBM 360 ocultaba completamente las diferencias tecnológicas entre varios modelos. Hito: El primer ISA diseñado como una interface hardware-software portable! Con pequeñas modificaciones, todavía sobrevive! ❿3

Conjunto de Instrucciones Instruction Set Architecture(ISA) El contrato entre el software y el hardware Típicamente se describe a través del estado visible al programador (registros y memoria) más la semántica de las instrucciones que operan sobre el estado El IBM 360 fue la primera línea de máquinas que separaron el ISA de su implementación (aka. Micro-arquitectura) Hay muchas implementaciones posibles para un ISA dado Ejemplo 1, los diferentes procesadores Intel x86 y los AMD Ejemplo 2, los soviéticos construyeron clones del IBM360, como lo hizo también Amdahl después de dejar IBM. Ejemplo 3, muchos celulares usan el ISA de ARM con implementaciones de diferentes compañías incluyendo TI, Qualcomm, Samsung, Marvell, etc. ❿4

Mapeo del ISA a la micro-arquitectura El ISA normalmente se diseña con un estilo de microarquitectura en mente Acumulador sin pipeline CISC micro código RISC con pipeline VLIW retardo fijo pipelines en orden y paralelos JVM interpretación de software Pero puede ser implementado con cualquier estilo de micro-arquitectura El Sandy Bridge de Intel: máquina con pipelinedcisc (x86) (con soporte de microcódigo) ARM Jazelle: procesador que implementa una JVM JVM: Java Virtual Machine ❿5

Micro-Arquitectura: Implementación de un ISA Lineas estado Controlador puntos control Data Path Flujo De datos Estructura: Como se conectan los componentes. Estático Comportamiento: Como se mueven los datos entre los componentes Dinámico ❿6

Evolución de los ISA Hasta el comienzo de los 80 los ISA seguían una filosofía CISC (ComplexInstructionSet Computers) Muchas instrucciones Posee instrucciones complejas que realizan la tarea de un conjunto de instrucciones más sencillas Posee muchos formatos de instrucción y modos de direccionamiento Posee diferentes clases de registros A partir de los 80, la tendencia ha sido seguir una filosofía RISC (Reduced Instruction Set Computers). La simplicidad facilita la decodificación y generación de código Las instrucciones son del mismo tamaño Las instrucciones del mismo tipo siguen el mismo formato En cuanto más pequeño, más rápido Refiriéndose a un menor número de instrucciones Un número relativamente bajo de tipos de registros ❿7

Por qué el MIPS? Estudiamos el ISA del MIPS para ilustrar los conceptos en lenguaje ensamblador y la organización de la máquina Los conceptos no son específicos del MIPS El MIPS es simplemente conveniente porque es real, pero simple (no como el x86) El ISA del MIPS es usado en muchos sitios, principalmente en sistemas embebidos Enrutadores de Cisco Consolas de juegos como el Nintendo 64, Sony Playstation 2 & PSP, y ahora Android se puede instalar Android in procesadores MIPS ❿8

Instrucciones del MIPS: registro a registro, 3 direcciones MIPS es una arquitectura de registro a registro, o load/store Las fuentes y el destino de las instrucciones tienen que ser registros Tiene instrucciones especiales para acceder memoria principal El MIPS usa instruccioned de 3 direcciones para manipulación de datos Cada instrucción de ALU contiene un destino y dos fuentes Por ejemplo, una instrucción de suma tiene la forma: instrucción operandos add a, b, c destino fuentes ❿9

Registros del MIPS Los procesadores MIPS tienen 32 registros, cada uno contiene un valor de 32 bits Las direcciones de los registros son de 5 bits (2 5 =32) 5 Write D address 32 D data Más registros parecieran ser mejor, pero hay un límite en lo bueno que puede ser: 5 32 32 Register File A address B address 5 Es más caro: por los propios registros, y además require más hardware, como multiplexores para seleccionar registros individuales A data B data 32 32 La longitud de las instrucciones puede ser afectada ❿10

Nombre de los registros del MIPS Los nombres de los registros del MIPS comienzan con $. Hay dos convenciones para nombrarlos: Por número: $0 $1 $2 $31 Pero (principalmente) con nombres con dos caracteres, como: $a0-$a3 $s0-$s7 $t0-$t9 $sp $ra No todos los registros son equivalentes: Por ejemplo, el registro $0 or$zerosiempre contiene el valor 0 Algunos tienen usos especiales, por convención ($spcontiene el puntero de la pila o stack pointer ) Hay que ser cuidadoso al escoger los registros para los programas Al principio es mejor limitarse a los registros $t0-$t9 ❿11

Políticas de uso de los registros Nombre Número Uso $zero $0 Constante 0 Callee must preserve? $at $1 Temporal ensamblador No $v0 $v1 $2-$3 Valores retorno funciones y evaluación de expresiones $a0 $a3 $4 $7 Argumentos funciones No $t0 $t7 $8 $15 Temporales No $s0 $s7 $16 $23 Temporales guardados $t8 $t9 $24 $25 Temporales $k0 $k1 $26 $27 Reservado Kernel OS $gp $28 Global pointer Si $sp $29 Stack pointer Si $fp $30 Frame pointer Si $ra $31 Dirección de retorno No Si No La mayoría de las herramientas (tool-chains) implementan convenciones paraelusodelosregistros. Estas convenciones las mantienen completamente elsoftwareynolorequiere el hardware ❿12

Aritmética básica e instrucciones lógicas Las instrucciones de aritmética entera incluyen: add sub mul div Algunas instrucciones lógicas: and or xor nor Recuerde que todas ellas requiren 3 registros, por ejemplo: add $t0, $t1, $t2 # $t0 = $t1 + $t2 mul $s1, $s1, $a0 # $s1 = $s1 x $a0 Nota: el ISA completo del MIPS se puede encontrar en internet ❿13

Expresiones complejas Las expresiones matemáticas complejas requieren múltiple instrucciones MIPS Ejemplo: t0 = (t1 + t2) x (t3 -t4) add $t0, $t1, $t2 # $t0 = $t1 + $t2 sub $t6, $t3, $t4 # $t6 = $t3 -$t4 mul $t0, $t0, $t6 # $t0 resultado final Registros temporales pueden ser necesarios, ya que cada instrucción MIPS puede acceder solo dos fuentes y un destino En este ejemplo, podríamos volver a usar $t3 en ves de usar $t6 Es importante no modificar los registros que son necesitados más adelante ❿14

Cómo se inicializan los registros? Instrucciones especiales del MIPS permiten especificar un valor constante, o inmediato ( immediate ) como segunda fuente en vez de un registro Por ejemplo, esta es la instrucción de suma con valor inmediato, addi: addi $t0, $t1, 4 # $t0 = $t1 + 4 Instrucciones con inmediato pueden ser usadas junto con el registro $zero para escribir constantes en los registros: addi $t0, $0, 4 # $t0 = 4 Atajo: li $t0, 4 # $t0 = 4 (pseudo-instrucción) También se puede definir una variable global, la cual es cargada en memoria junto con el ejecutable y luego se puede cargar con una instrucción para acceder estas constantes ❿15

Un programa en el MIPS Comparemos el programa de C y el de MIPS: void main() { int i = 516; int j = i*(i+1)/2; i = i + j; } main: # comienzo del main li $t0, 516 # i = 516 addi $t1, $t0, 1 # i + 1 mul $t1, $t0, $t1 # i * (i + 1) li $t2, 2 div $t1, $t1, $t2 # j = i*(i+1)/2 add $t0, $t0, $t1 # i = i + j jr $ra # return ❿16

Se necesita más espacio! Los registros son rápidos y convenientes, pero solo se tiene 32, y de solo 32 bits cada uno Esto no es suficiente para guardar estructuras de datos como grandes vectores Tampoco permite acceder datos que son más grandes de 32 bits Se necesita añadir memoria al sistema! La RAM es más barata y más densa que los registros, por lo tanto podemos añadir mucha Pero la memoria es significativamente más lenta, por lo tanto los registros deben ser usados siempre que sea posible ❿17

Memoria del MIPS 2 32 8 memory 32 8 ADRS DATA OUT 8 CS WR La memoria del MIPS se direcciona por byte, lo que significa que cada referencia a memoria referencia una cantidad de 8 bits La arquitectura (original) del MIPS puede soportar hasta 32 líneas de direcciones Esto resulta en 2 32 x 8B RAM, lo que resulta en 4 GB de memoria. No todas las implementaciones reales tendrán todo esto! Address 0 1 2 3 4 5 6 7 8 9 10 11 8-bit data ❿18

Load y Storede Bytes El ISA del MIPS tiene instrucciones de acceso a memoria El MIPS usa direccionamiento indexado Las instrucciones especifican una dirección con una constante con signo y un registro Estos valores son sumados para obtener la dirección efectiva La instrucción load byte lb transfiere un byte de datos desde la memorias principal a un registro lb $t0, 20($a0) # $t0 = Memory[$a0 + 20] Cuando se carga un byte (8 bits) en un registro de 32 bits, los otros 24 bits tendrán el mismo valor que el bit más significativo del byte cargado La instrucción storebyte sbtransfiere el byte menos significativo del registro a la dirección de memoria principal sb$t0, 20($a0) # Memory[$a0 + 20] = $t0 ❿19

Ejemplo del uso de la memoria char from = 1, to = 0;.data from:.byte 1 to:.byte 0 void main() { } to = from;.text main: la $t0, from lb $t1, 0($t0) la $t0, to sb $t1, 0($t0) ❿20

Tipos de datos del MIPS MIPS opera sobre Enteros de 32 bits (sin signo o en complemento a dos) Punto flotante de precisión simple de 32 bits Punto flotante de doble precisión de 64 bits Los bytes o halfwordscargados en los GPRsson expandidos con cero o por signo hasta completar los 32 bits Solamente unidades de 32 bits pueden ser cargados en los FPRs Los números de punto flotante de 64 bits requieren dos FPRs consecutivos para ser almacenados ❿21

Load y Storede palabras También se puede cargar y guardar palabras de 32 bits con las instrucciones lw y sw lw$t0, 20($a0) # $t0 = Memory[$a0 + 20] sw$t0, 20($a0) # Memory[$a0 + 20] = $t0 La mayoría de los lenguajes de programación soportan tipos de datos de 32 bits Enteros Números de punto flotante de precisión simple Direcciones de memoria o punteros Mientras no se diga lo contrario consideraremos la palabra (word) la unidad básica de los datos ❿22

Arreglo de palabras Si asumimos que un arreglo de palabras comienza en la dirección 2000 El primer elemento está en la dirección2000 El segundo está en la dirección 2004, y no en el 2001 De la diapositiva anterior, si $a0 contiene 2000, luego lw $t0, 0($a0) accede la primera palabra del arreglo, mientras que lw $t0, 8($a0) accede a la tercera palabra del arreglo en la dirección 2008. ❿23

Alineamiento de la memoria Recuerde que la memoria se direcciona en unidades de bytes, por lo tanto una palabra de 32 bits ocupa 4 direcciones en bytes de la memoria principal Address 0 1 2 3 4 5 6 7 8 9 10 11 8-bit data La arquitectura del MIPS requiere que las palabras estén alineadas en memoria; las palabras de 32 bits tienen que comenzar en direcciones divisibles por 4 0, 4, 8 y 12 son direcciones de palabras válidas Word 1 Word 2 Word 3 1, 2, 3, 5, 6, 7, 9, 10 y 11 no lo son Acceso de memoria a direcciones no alineadas resulta en error de bus bus error Esta restricción tiene relativamente poco efecto en lenguajes de alto nivel y los compiladores, pero simplifica el diseño del procesador y lo hace más rápido ❿24

Mapeo de memoria I/O Las instrucciones de transferencia de datos también pueden ser usadas para mover datos desde y hacia registros de dispositivos de I/O Una operación de load mueve datos desde un registro de un dispositivo de I/O a un registro del CPU Una operación de storemueve datos desde un registro del procesador a un registro de un dispositivo de I/O ❿25

Seudoinstruciones Los ensambladores de MIPS soportan seudoinstrucciones, las cuales dan la ilusión de una instrucción más compleja, pero son traducidas en una o más instrucciones más simples o reales Instrucciones como li $a0, 2000 # Cargar el 2000 en $a0 move $a1, $t0 # Copia $t0 en $a1 Son más claras que las instrucciones MIPS reales addi $a0, $0, 2000 # Inicializa $a0 a 2000 add $a1, $t0, $0 # Copia $t0 en $a1 ❿26

Control de flujo en lenguajes de alto nivel Las instrucciones en un programa usualmente ejecutan una detrás de las otra, pero a menudo se necesita alterar el flujo normal Expresiones condicionales se ejecutan solo si una expresión es verdadera // Encontrar el valor absoluto de *a0 v0 = *a0; if (v0 < 0) v1 = v0; v0 = -v0; // Esto puede no ser ejecutado Bucles (loops) hacen que algunas expresiones se ejecuten muchas veces // Suma de elementos de un arreglo de 5 elementos a0 v0 = 0; t0 = 0; while (t0 < 5) { v0 = v0 + a0[t0];// Estas 2 expresiones serán t0++; // ejecutadas 5 veces } ❿27

Instrucciones de control del MIPS Algunas instrucciones de control de flujo del MIPS j // para saltos sin condiciones bney beq // Salta si registros no (y si) son iguales slty slti // registro a 1 si registro menor que otro //(y si es menor que inmediato) El MIPS solo soporta dos instrucciones de salto, beqybne, pero para simplificar el ensamblador provee estas otras instrucciones de salto blt $t0, $t1, L1 // Saltar si $t0 < $t1 ble $t0, $t1, L2 // Saltar si $t0 <= $t1 bgt $t0, $t1, L3 // Saltar si $t0 > $t1 bge $t0, $t1, L4 // Saltar si $t0 >= $t1 También hay versiones con inmediatos de estas instrucciones de salto, donde el segundo campo de fuente es una constante y no un registro Luego se verá por que al soportar solo beqy bnesimplifica el diseño del procesador ❿28

Implementación de seudosaltos La mayoría de los seudosaltosson implementados usando slt. Por ejemplo, un salto si es menor que (branch-if-less-than) blt$a0, $a1, Label es traducida en lo siguiente slt $at, $a0, $a1 // $at = 1 si $a0 < $a1 bne $at, $0, Label // Salto si $at!= 0 Esto permite saltos con inmediatos, los cuales son también seudoinstrucciones. Por ejemplo, blti$a0, 5, Labelse traducen en dos instrucciones slti $at, $a0, 5 // $at = 1 si $a0 < 5 bne $at, $0, Label // Branchif$a0 < 5 Todas los seudosaltosnecesitan un registro para guardar los resultados de slt, a pesar de no ser necesitado después El ensamblador de MIPS usa el registro $1, o $at, para el temporal Se debe ser cuidadoso cuando se usa $at en un programa, ya que puede ser re-escrito por el código generado por el ensamblador ❿29

Traducir un if-thena MIPS Podemos usar instrucciones de salto para traducir if-thena ensamblador de MIPS v0 = *a0; ld $t0, 0($a0) if (v0 < 0) bge $t0, $0, E v0 = -v0; sub $t0, $zero, $t0 v1 = v0; E: add $t1, $t0, $zero Algunas veces es más fácil invertir la condición original En este caso cambiamos continuar si v0 < 0 por saltar si v0 >= 0. Esto ahorra algunas instrucciones en el código resultante ❿30

Ensamblador versus Lenguaje de máquina Hasta el momento hemos usado lenguaje ensamblador Le asignamos nombres a las instrucciones (como add) y al los registros (como $t0). Para los saltos usamos labels en vez de direcciones reales Además el ensamblador acepta muchas seudoinstrucciones Pero los programas tienen que ser traducidos a lenguaje de máquina eventualmente, un formato binario que puede ser guardado en memoria y decodificado por el procesador El lenguaje de máquina del MIPS está diseñado para ser fácilmente decodificado Todas las instrucciones del MIPS tienen la misma longitud, 32 bits Solo hay 3 formatos de instrucciones diferentes, los cuales son muy parecidos Al estudiar el lenguaje de máquina del MIPS se verán algunas restricciones del conjunto de instrucciones ISA, y como pueden ser superadas ❿31

Formato tipo R (R-type) Las instrucciones aritméticas de Registro a registro usan este formato op rs rt rd shamt func 6 bits 5 bits 5 bits 5 bits 5 bits 6 bits Este formato tiene 6 campos opes el código de una instrucción que selecciona una operación específica rsy rtson el primero y segundo registros fuentes rdes el registro destino shamt solo se usa para instrucciones shift funces usado junto con oppara seleccionar la operación aritmética ❿32

Registros y tamaño de las instrucciones Como el MIPS tiene 32 registros, se requieren números de 5 bits para codificarlos desde 00000 al 11111 Por ejemplo, el registro $t8es el $24, el cual está representado por el 11000 El número de registros disponibles afecta la longitud de las instrucciones Cada instrucción tipo R referencia 3 registros, los cuales requieren un total de 15 bits en la palabra de la instrucción No podemos añadir más registros sin incrementar el tamaño de las instrucciones de 32 bits, o reducir otros campos como el opy reducir el número de instrucciones posibles Otros tipos de ISA, como los de Stackno gastan espacio de instrucciones en registros. ❿33

Formato tipo I Las instrucciones Load, store, salto y algunas aritméticas todas tienen una versión con inmediato y usan el formato I-type op rs rt address 6 bits 5 bits 5 bits 16 bits Por uniformidad, op, rsy rtestán en la misma posición que en el formato R El significado de los registros depende de la instrucción rses el registro fuente una dirección para loadsy stores, o un operando para las instrucciones de saltos y aritméticas rtes un registro fuente para saltos y stores, pero es un registro destino para instrucciones aritméticas y loads tipo I El addresses un valor con signo en complemento a dos de 16 bits Puede ir desde -32,768 a +32,767. Pero esto no es siempre suficiente! ❿34

Constantes más grandes Cuando se requiere usar constantes más grandes de 16 bits Se usa la instrucción cargar inmediato en la parte alta load upper immediate instruction luila cual carga los 16 bits más significativos de un registro con una constante, y vuelve cero los 16 bits menos significativos Y se complementa con un OR inmediato, ori, que carga los 16 bits menos significativos Para cargar el valor de 32 bits 0000 0000 0011 1101 0000 1001 0000 0000: lui $s0, 0x003D # $s0 = 003D 0000 (en hex) ori $s0, $s0, 0x0900 # $s0 = 003D 0900 Esto ilustra el principio de hacer el caso más común más rápido La mayoría de las veces las constantes de 16 bits son suficientes Es posible cargar constantes de 32 bits, pero el costo es: dos instrucciones y un registro temporal Las seudoinstrucciones pueden contener constantes de más de 32 bits ❿35

Load y Storesde grandes direcciones El tamaño limitado de 16 bits puede ser un problema para acceder datos globales Si se quiere poner los resultados de una operación en la dirección 0x10010004 Nos damos cuenta que 0x10010004 es mayor que 32,767 En estos casos, el ensamblador rompe el inmediato en dos partes lui $at, 0x1001 # 0x1001 0000 lw $t1, 0x0004($at) # Leer de Mem[0x1001 0004] ❿36

Saltos Para las instrucciones de salto, el valor del inmediato no es una dirección, sino un offset desde el contador de programa (PC) actual a una dirección destino beq $at, $0, L add $v1, $v0, $0 add $v1, $v1, $v1 j Algun_sitio L: add $v1, $v0, $v0 Ya que el destino del salto Les 3 instrucciones después de beq, el campo del inmediato contiene 3. La instrucción beq será almacenada como: 000100 00001 00000 0000 0000 0000 0011 op rs rt address ❿37

Saltos largos Estudios empíricos de programas reales muestra que la mayoría de los saltos son de menos de 32,767 instrucciones más allá los saltos son usados principalmente en bucles y condicionales, y a los programadores les enseñan a hacer cuerpos de código cortos Si se necesitara saltar más largo, por ejemplo, si Lejos es muy lejos, entonces: puede ser simulado con beq $s0, $s1, Lejos... bne $s0, $s1, Next j Lejos Next:... Una vez más, los diseñadores del MIPS se preocuparon del caso común primero ❿38

Formato tipo J Finalmente, la instrucción salto jump usa el formato tipo J op address 6 bits 26 bits La instrucción jump contiene una palabra de dirección no un offset Recordemos que las instrucciones del MIPS son de tamaño de palabra, y una dirección debe ser divisible por 4 Por lo tanto en ves de decir saltar a la dirección 4000, es suficiente decir saltar a la dirección 1000. Una dirección de 26 bits permite saltar a cualquier dirección de 0 a 2 28. Para saltos aún más largor se puede usar la instrucción salto de registro jr jr $ra # Salto a dirección de 32 bits en registro $ra ❿39

Fuentes de Información Parte de este material fue tomado de Krste Asanovic(UC Berkeley, curso cs152) Este a suvezda el siguienteacknowledgment: These slides contain material developed and copyright by: Arvind(MIT) Krste Asanovic(MIT/UCB) Joel Emer(Intel/MIT) James Hoe (CMU) John Kubiatowicz(UCB) David Patterson (UCB) MIT material derived from course 6.823 UCB material derived from course CS252 Tambiénse usamaterial del Prof. Craig Zilles(UIUC, curso CS232) ❿40