Introducción a MIPS

MIPS

 MIPS (Microprocessor without Interlocked Pipeline Stages) es una familia de microprocesadores RISC desarrollados por MIPS Technologies.

 RISC (Reduced Instruction Set Architecture) es una estrategia de diseño de CPUs donde cada instrucción tiene una sola función y se ejecuta de manera rápida.

 Es lo contrario de CISC (Complex Instruction Set Architecture), donde cada instrucción hace muchas funciones.

Universidad de Sonora Arquitectura de Computadoras 2

RISC/CISC

 Ejemplos de RISC incluyen Alpha, ARC, ARM, AVR, MIPS , PA-RISC, PIC, PowerPC, SuperH, and SPARC.

 Ejemplos de CISC incluyen las familias Motorola 68000 e Intel 80x86.

Universidad de Sonora Arquitectura de Computadoras 3

MIPS

 El primer MIPS fue desarrollado en 1981 por John L. Hennessy en Stanford University.

 Principio de regularidad . Todas las instrucciones ocupan 4 bytes (32 bits).

 Principio de simplicidad . Instrucciones sencillas. Solo hay 3 formatos de instrucción.

 Usados, entre otros, en algunas consolas de videojuego de Nintendo y Sony y sistemas empotrados como ruteadores Cisco, dispositivos Windows CE, gateways, etc.

Universidad de Sonora Arquitectura de Computadoras 4

Aritmética MIPS

 Todas las instrucciones aritméticas tienen 3 operandos  El orden de los operandos es fija (primero el operando destino) Ejemplo: C: MIPS: A = B + C add $s0, $s1, $s2 (las variables son asociadas por el compilador) Universidad de Sonora Arquitectura de Computadoras 5

Aritmética MIPS

 La simplicidad favorece la regularidad.

C: A = B + C + D; E = F - A; MIPS: add $t0, $s1, $s2 add $s0, $t0, $s3 sub $s4, $s5, $s0  Los operandos de las instrucciones aritméticas deben ser registros.

Universidad de Sonora Arquitectura de Computadoras 6

¿Registros?

 Un registro es una memoria integrada en la CPU.

 Tienen poca capacidad, 4 bytes (32 bits) en MIPS, pero de acceso muy rápido.

 Se usan para guardar valores temporales y resultados de operaciones aritméticas.

Universidad de Sonora Arquitectura de Computadoras 7

Registros vs. Memoria

 Los operandos de las instrucciones aritméticas deben ser registros.

 Solo hay 32 registros disponibles en MIPS.

 El compilador asocia las variables con los registros.

 ¿Y los programas con muchas variables?

 Las variables se guardan en la memoria principal.

Universidad de Sonora Arquitectura de Computadoras 8

Registros vs. Memoria

 La mayoría de las CPUs modernas mueven las variables de la memoria principal a los registros, operan sobre ellos y regresan el resultado a la memoria.

 A esto se le conoce como arquitectura load/store .

 MIPS emplea arquitectura load/store.

Universidad de Sonora Arquitectura de Computadoras 9

Organización de la memoria

 MIPS usa byte addressing, el índice apunta a un byte de memoria.

0 1 2 3 4 5 ...

8 bits of data 8 bits of data 8 bits of data 8 bits of data 8 bits of data 8 bits of data

10 Universidad de Sonora Arquitectura de Computadoras

Organización de la memoria

 Las palabras son de 4 bytes (32 bits).

 Los registros son de 4 bytes (32 bits).

 La memoria está alineada . Las palabras deben comenzar en direcciones que son múltiplo de 4.

0 4 8 12 ...

Datos 32 bits Datos 32 bits Datos 32 bits Datos 32 bits

Universidad de Sonora Arquitectura de Computadoras 11

Organización de la memoria

 MIPS se puede configurar por hardware como big endian o little–endian.

 Se usan 32 bits para direccionar la memoria.

 La memoria tiene:  2 32 bytes con dirección desde 0 hasta 2 32 – 1.

 2 30 palabras con dirección desde 0 hasta 2 32 – 4.



¿Qué significan los 2 bits menos significativos de una dirección de palabra?

Universidad de Sonora Arquitectura de Computadoras 12

Instrucciones de referencia a memoria

 Instrucciones lw (load word) y sw (store word).

C: MIPS: A[8] = h + A[8]; lw $t0, 32($s3) add $t0, $s2, $t0 sw $t0, 32($s3) ; t0 = Memoria[s3 + 32] ; t0 = s2 + t0 ; Memoria[s3 + 32] = t0 s2 valor de h s3 dirección A[0] t0 valor de A[8]

Ojo:

lw – el destino va primero .

sw – el destino va segundo .

Universidad de Sonora Arquitectura de Computadoras 13

Operandos de memoria

 En las instrucciones de memoria, a la constante se le llama offset y al registro que se suma para obtener la dirección se le llama registro base.

 Por ejemplo: lw $t0, 32($s3) sw $t0, 32($s3)  32 es el offset.

 El registro base es $s3.

; $to = Memoria[$s3 + 32] ; Memoria[$s3 + 32] = $t0 Universidad de Sonora Arquitectura de Computadoras 14

En resumen:

 MIPS    Carga palabras pero direcciona bytes.

Puede ser big-endian o little-endian.

Aritmética usa solamente registros.

 Instrucción add $s1, $s2, $s3 sub $s1, $s2, $s3 lw $s1, 100($s2) sw $s1, 100($s2) Significado $s1 = $s2 + $s3 $s1 = $s2 – $s3 $s1 = Memoria[$s2+100] Memoria[$s2+100] = $s1 Universidad de Sonora Arquitectura de Computadoras 15

El primer ejemplo

swap(int v[], int k) { int temp; temp = v[k] v[k] = v[k+1]; v[k+1] = temp; } swap: muli $2, $5, 4 add $2, $4, $2 lw $15, 0($2) lw $16, 4($2) sw $16, 0($2) sw $15, 4($2) jr $31

Universidad de Sonora Arquitectura de Computadoras 16

swap: 1 muli $2, $5, 4 2 add $2, $4, $2 3 lw $15, 0($2) 4 lw $16, 4($2) 5 sw $16, 0($2) 6 sw $15, 4($2) 7 jr $31

El primer ejemplo

swap: 1 $2 = $5 * 4 ; $5 tiene el valor de k 2 $2 = $4 + $2 ; $4 apunta a v[0], $2 apunta a v[k] 3 $15 = Mem[$2+0] ; $15 tiene el valor de v[k] 4 $16 = Mem[$2+4] ; $16 tiene el valor de v[k+1] 5 Mem[$2+0] = $16 ; $16 se guarda en v[k] 6 Mem[$2+4] = $15 ; $15 se guarda en v[k+1] 7 jr $31 ; return

17 Universidad de Sonora Arquitectura de Computadoras

El primer ejemplo

 { Ahora en seudo-C con apuntadores swap (int v[], int k) $4 = &v[0]; $5 = k; $2 = $5 * 4; $2 = $4 + $2 $15 = *($2 + 0) $16 = *($2 + 4) *($2 + 0) = $16; *($2 + 4) = $15; // inicializa // 1 // 2 // 3 // 4 // 5 // 6 $2 es (&v[k] - &v[0]) $2 apunta a v[k] $15 tiene el valor de v[k] $16 tiene el valor de v[k+1] $16 se guarda en v[k] $15 se guarda en v[k+1] } Universidad de Sonora Arquitectura de Computadoras 18

El primer ejemplo

 Y ahora en C normal: } { swap (int v[], int k) int t1 = v[k]; int t2 = v[k + 1]; v[k] = t2; v[k + 1] = t1; Universidad de Sonora Arquitectura de Computadoras 19

Lenguaje de máquina

 El lenguaje de máquina es lenguaje binario.

 El hardware solo entiende bits.

 El ensamblador traduce cada instrucción de lenguaje ensamblador a lenguaje de máquina.

 Por ejemplo, la instrucción add $t0, $s1, $s2 se traduce a 00000010001100100100100000100000 Universidad de Sonora Arquitectura de Computadoras 20

Lenguaje de máquina

00000010001100100100100000100000 se descompone en:  000000 es el opcode del add.

 10001 es el número del registro $s1.

 10010 es el número del registro $s2.

 01001 es el número del registro $t0.

 00000 son bits de relleno (don’t care).

 100000 es el código de la suma de registros.

Universidad de Sonora Arquitectura de Computadoras 21

1.

2.

3.

4.

5.

6.

Lenguaje de máquina

En general, la instrucción add destino, fuente1, fuente2 genera el código máquina 000000fffffgggggdddddxxxxx100000 donde 000000 es el código del add.

fffff es el número del registro fuente 1 ggggg es el número del registro fuente 2 ddddd es el número del registro destino xxxxx son don’t care 100000 es el código de la suma de registros.

Universidad de Sonora Arquitectura de Computadoras 22

Formatos de instrucción

Hay 3 formatos de instrucción:  Formato R. Todos los operandos son registros.

 Formato I. Hay un operando inmediato (número).

 Formato J. La instrucción es un brinco (jump).

Universidad de Sonora Arquitectura de Computadoras 23

Formatos de instrucción

Ejemplos:  Formato R.

add $t0, $s1, $s2  Formato I.

addi $t0, $s1, C  Formato J.

j C ; $t0 = $s1 + $s2 ; $t0 = $s1 + C [número de 16 bits] ; brinca a C [dirección de 16 bits] 24 Universidad de Sonora Arquitectura de Computadoras

Instrucciones de control

 Instrucciones de toma de decisión.

 Alteran el flujo de control.

 En otras palabras, cambian la siguiente instrucción que será ejecutada.

Universidad de Sonora Arquitectura de Computadoras 25

Instrucciones de control

En MIPS hay dos instrucciones de brinco condicional: 1.

beq $s, $t, C 2.

bne $s, $t, C ; brinca a la dirección C si $s == $t.

; brinca a la dirección C si $s != $t.

Universidad de Sonora Arquitectura de Computadoras 26

Instrucciones de control

Ejemplo: C: MIPS: L1: if (i == j) h = i + j; bne $t1, $t2, L1 add $t0, $t1, $t2 … ; $t1: valor de i, $t2: valor de j ; $t0: valor de h Universidad de Sonora Arquitectura de Computadoras 27

Instrucciones de control

En MIPS hay tres instrucciones de brinco incondicional: 1.

2.

j C jr $r ; brinca a la dirección C ; brinca a la dirección guardada en $r 3.

jal C Universidad de Sonora ; llama al procedimiento que comienza en C ; la dirección de regreso se guarda en $31 ; es decir, se regresa con jr $31 Arquitectura de Computadoras 28

Ejemplo:

Instrucciones de control

C: MIPS: L1: L2: if (i != j) h = i + j; else h = i – j; bne $s1, $s2, L1 sub $s0, $s1, $s2 ; $s1 = i, $s2 = j ; $s0 = h j L2 add $s0, $s1, $s2 … ; brinca al final ; $s0 = h Universidad de Sonora Arquitectura de Computadoras 29

C Ejemplo:

Instrucciones de control

{ foo (); … void foo () } … MIPS: foo: Universidad de Sonora jal foo … … jr $31 ; brinca a foo, guarda la dirección de ; regreso en el registro 31 ; regresa al programa principal Arquitectura de Computadoras 30

Instrucciones de control

 MIPS tiene beq (brinca si es igual) y bne (brinca si no es igual). ¿Y si la condición es if (i < j) ?

 Existe la instrucción slt (set if less than): slt $t0, $t1, $t2  slt es equivalente en seudo C a $t0 = ($t1 < $t2)  $t0 vale 1 si $t1 es menor que $t2 y vale 0 en otro caso.

 slt se usa junto con beq o bne para condiciones if (i < j) .

Universidad de Sonora Arquitectura de Computadoras 31

Ejemplo:

Instrucciones de control

C: if (i < j) h = i + j; else h = i – j; MIPS: L1: L2: Universidad de Sonora slt $s3, $s1, $s2 beq $s3, $zero, L1 add $s0, $s1, $s2 j L2 sub $s0, $s1, $s2 … Arquitectura de Computadoras ; $s1 = i, $s2 = j $s3 = i < j ; $zero siempre vale 0 ; then h = i + j ; brinca al final ; else h = i - j 32

C: Ejemplo:

Instrucciones de control

MIPS: L3: L1: L2: if (i <= j) h = i + j; else h = i – j; beq $s1, $s2, L3 slt $s3, $s1, $s2 beq $s3, $zero, L1 add $s0, $s1, $s2 j L2 sub $s0, $s1, $s2 … ; brinca si $s1 == $s2 ; checa su $s1 < $s2 ; $zero siempre vale 0 ; then $s0 = $s1 + $s2 ; brinca al final ; else $s0 = $s1 - $s2 Universidad de Sonora Arquitectura de Computadoras 33

Instrucción

Resumen

Significado

add $s1,$s2,$s3 sub $s1,$s2,$s3 lw $s1,100($s2) sw $s1,100($s2) bne $s4,$s5,L beq $s4,$s5,L j L jal L Universidad de Sonora $s1 = $s2 + $s3 $s1 = $s2 – $s3 $s1 = Memoria[$s2+100] Memoria[$s2+100] = $s1 Sig. instr. es L si $s4 != $s5 Sig. instr. es L si $s4 = $s5 Sig. instr. es L Llama al procedimiento L Arquitectura de Computadoras 34

Constantes

 Las instrucciones con formato I (inmediato), tienen una constante en su tercer operando.

 Las constantes están limitadas a 16 bits con signo.

 Por ejemplo: addi $29, $29, 4 slti $8, $18, 10 andi $29, $29, 6 ori $29, $29, 0xFF ; $29 = $29 + 4 ; $8 = $18 < 10 ; $29 = $29 & 6 ; $29 = $29 | 0xFF Universidad de Sonora Arquitectura de Computadoras 35

  

Constantes

1.

2.

Se pueden tener constantes de 32 bits, pero solo si se almacenan en un registro.

Se necesitan dos instrucciones (o una seudo instrucción, como se verá después): lui $x, C ori $x, C ; guarda C en los 16 bits mas ; significativos del registro $x ; guarda C en los 16 bits menos ; significativos del registro $x En lugar de ori se puede usar: addi $x, $zero, C Universidad de Sonora Arquitectura de Computadoras 36