Académique Documents
Professionnel Documents
Culture Documents
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 diseo de CPUs donde cada instruccin tiene una sola funcin y se ejecuta de manera rpida. Es lo contrario de CISC (Complex Instruction Set Architecture), donde cada instruccin hace muchas funciones.
Universidad de Sonora
Arquitectura de Computadoras
RISC/CISC
Ejemplos de RISC incluyen Alpha, ARC, ARM, AVR,
Universidad de Sonora
Arquitectura de Computadoras
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 instruccin. 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
Aritmtica MIPS
Todas las instrucciones aritmticas tienen 3 operandos
El orden de los operandos es fija (primero el operando
Aritmtica MIPS
La simplicidad favorece la regularidad.
C:
A = B + C + D; E = F - A;
add $t0, $s1, $s2 add $s0, $t0, $s3 sub $s4, $s5, $s0 Los operandos de las instrucciones aritmticas deben ser registros.
Universidad de Sonora Arquitectura de Computadoras 6
MIPS:
Registros?
Un registro es una memoria integrada en la CPU. Tienen poca capacidad, 4 bytes (32 bits) en MIPS, pero
de acceso muy rpido. Se usan para guardar valores temporales y resultados de operaciones aritmticas.
Universidad de Sonora
Arquitectura de Computadoras
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
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
Organizacin 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
Universidad de Sonora
Arquitectura de Computadoras
10
Organizacin 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
Universidad de Sonora
Arquitectura de Computadoras
11
Organizacin de la memoria
MIPS se puede configurar por hardware como big-
MIPS:
Arquitectura de Computadoras
Operandos de memoria
En las instrucciones de memoria, a la constante se le
llama offset y al registro que se suma para obtener la direccin se le llama registro base. Por ejemplo: lw $t0, 32($s3) ; $to = Memoria[$s3 + 32] sw $t0, 32($s3) ; Memoria[$s3 + 32] = $t0 32 es el offset. El registro base es $s3.
Universidad de Sonora
Arquitectura de Computadoras
14
En resumen:
MIPS Carga palabras pero direcciona bytes. Puede ser big-endian o little-endian. Aritmtica usa solamente registros.
Instruccin
Significado
$s1 = $s2 + $s3 $s1 = $s2 $s3 $s1 = Memoria[$s2+100] Memoria[$s2+100] = $s1
add $s1, $s2, $s3 sub $s1, $s2, $s3 lw $s1, 100($s2) sw $s1, 100($s2)
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
El primer ejemplo
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 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
Universidad de Sonora
Arquitectura de Computadoras
17
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; }
Universidad de Sonora Arquitectura de Computadoras 18
// inicializa
// 1 - $2 es (&v[k] - &v[0]) // 2 - $2 apunta a v[k] // 3 - $15 tiene el valor de v[k] // 4 - $16 tiene el valor de v[k+1] // 5 - $16 se guarda en v[k] // 6 - $15 se guarda en v[k+1]
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 mquina
El lenguaje de mquina es lenguaje binario.
El hardware solo entiende bits. El ensamblador traduce cada instruccin de lenguaje
ensamblador a lenguaje de mquina. Por ejemplo, la instruccin add $t0, $s1, $s2 se traduce a 00000010001100100100100000100000
Universidad de Sonora
Arquitectura de Computadoras
20
Lenguaje de mquina
00000010001100100100100000100000 se descompone en:
000000 es el opcode del add. 10001 es el nmero del registro $s1. 10010 es el nmero del registro $s2. 01001 es el nmero del registro $t0. 00000 son bits de relleno (dont care). 100000 es el cdigo de la suma de registros.
Universidad de Sonora
Arquitectura de Computadoras
21
Lenguaje de mquina
En general, la instruccin add destino, fuente1, fuente2 genera el cdigo mquina 000000fffffgggggdddddxxxxx100000 donde
1. 2. 3. 4. 5. 6.
000000 es el cdigo del add. fffff es el nmero del registro fuente 1 ggggg es el nmero del registro fuente 2 ddddd es el nmero del registro destino xxxxx son dont care 100000 es el cdigo de la suma de registros.
Universidad de Sonora
Arquitectura de Computadoras
22
Formatos de instruccin
Hay 3 formatos de instruccin:
Formato R. Todos los operandos son registros. Formato I. Hay un operando inmediato (nmero). Formato J. La instruccin es un brinco (jump).
Universidad de Sonora
Arquitectura de Computadoras
23
Formatos de instruccin
Ejemplos:
Formato R.
Universidad de Sonora
Arquitectura de Computadoras
24
Instrucciones de control
Instrucciones de toma de decisin.
Alteran el flujo de control. En otras palabras, cambian la siguiente instruccin
Universidad de Sonora
Arquitectura de Computadoras
25
Instrucciones de control
En MIPS hay dos instrucciones de brinco condicional:
1.
Universidad de Sonora
Arquitectura de Computadoras
26
Instrucciones de control
Ejemplo:
C: 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
MIPS:
L1:
Universidad de Sonora
Arquitectura de Computadoras
27
Instrucciones de control
En MIPS hay tres instrucciones de brinco incondicional:
1.
jC
; brinca a la direccin C ; brinca a la direccin guardada en $r ; llama al procedimiento que comienza en C ; la direccin de regreso se guarda en $31 ; es decir, se regresa con jr $31
Arquitectura de Computadoras 28
2. jr $r 3. jal C
Universidad de Sonora
Instrucciones de control
Ejemplo:
C: if (i != j) h = i + j; else h = i j; bne $s1, $s2, L1 ; $s1 = i, $s2 = j sub $s0, $s1, $s2 ; $s0 = h j L2 ; brinca al final add $s0, $s1, $s2 ; $s0 = h
Arquitectura de Computadoras 29
MIPS:
L1: L2:
Universidad de Sonora
Instrucciones de control
Ejemplo:
C foo (); void foo () { }
MIPS:
foo:
Universidad de Sonora
Arquitectura de Computadoras
Instrucciones de control
MIPS tiene beq (brinca si es igual) y bne (brinca si no
es igual). Y si la condicin es if (i < j)? Existe la instruccin 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
Instrucciones de control
Ejemplo:
C: if (i < j) h = i + j; else
h = i j;
MIPS: slt $s3, $s1, $s2 beq $s3, $zero, L1 add $s0, $s1, $s2 j L2 sub $s0, $s1, $s2
Arquitectura de Computadoras
L1: L2:
Universidad de Sonora
; $s1 = i, $s2 = j $s3 = i < j ; $zero siempre vale 0 ; then h = i + j ; brinca al final ; else h = i - j
32
Instrucciones de control
Ejemplo: C: 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
Arquitectura de Computadoras
MIPS:
L3:
L1: L2:
Universidad de Sonora
; brinca si $s1 == $s2 ; checa su $s1 < $s2 ; $zero siempre vale 0 ; then $s0 = $s1 + $s2 ; brinca al final ; else $s0 = $s1 - $s2
33
Resumen
Instruccin
add $s1,$s2,$s3 sub $s1,$s2,$s3 lw $s1,100($s2) sw $s1,100($s2) bne $s4,$s5,L beq $s4,$s5,L jL jal L
Universidad de Sonora
Significado
$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 estn limitadas a 16 bits con signo. Por ejemplo: addi $29, $29, 4 ; $29 = $29 + 4 slti $8, $18, 10 ; $8 = $18 < 10 andi $29, $29, 6 ; $29 = $29 & 6 ori $29, $29, 0xFF ; $29 = $29 | 0xFF
Universidad de Sonora
Arquitectura de Computadoras
35
Constantes
Se pueden tener constantes de 32 bits, pero solo si se almacenan en un registro. Se necesitan dos instrucciones (o una seudo instruccin, como se ver despus):
1.
2.
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
Universidad de Sonora