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: 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).
TIPOS DE INSTRUCCIONES MIPS
Aritmetico – logicasEmpleadas para manipular datos en registros.
beq $s1, $s2, 25 if ($s1==$s2) PC = PC + 4 + 4*25
Transferencia de datosMueven los datos de registros desde/hacia memoria
SaltoAlteran el flujo de ejecución de un programa
add $s1, $s2, $s3 $s1 = $s2 + $s3or $s3, $s4, $s5 $s3 = $s4 OR $s5
lw $s1, 100($s2) $s1 = Memory[$s2 + 100]sw $s1, 100($s2) Memory[$s2 + 100] = $s1
Serán tratadas mas adelante
INSTRUCCIONES ARITMETICO-LOGICAS
Uso de la instrucción:
add dest, src1, src2 #dest = src1 + src2sub dest, src1, src2 #dest = src1 - src2and 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
Formado de la instruccion:
lw $dest, offset($addr) # load wordsw $src, offset($addr) # store word
• Transfieren datos entre registros y memoria.• Ojo: Los operandos aritmeticos son registros, no memoria.
• 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, $t0sw $t0, 32($s3)
EJEMPLO: CARGANDO UNA VARIABLE SIMPLE
EJEMPLO: CARGANDO UN ARRAY
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
lw $9, 1200($8) == lw $t1, 1200($t0)
add $8, $17, $18
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
Processor
Memory
C/C++ statement
A = B + C;
LW $S1, (address of B)LW $S2, (address of C)
ADD $S3, $S2, $S1
SW $S3, (address of A)
Assembly instructions
S1S2S3
BC
B
C
A
LW (Load Word)LW (Load Word)
SW (Store Word)B+C
+
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 bnebeq
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
Si (rs==rt) salta a la instrucción etiquetada con Label.
FORMATO I
SALTOS CONDICIONALES – CALCULO DE LA DIRECCION
¿Cómo se calculan las direcciones?Programa almacenado (Modelo de Von Newman).
Memory
4C000000Assembled
+Loaded
***.asm
My_Address:
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.
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.
4 rs rt Offset 16 bits
opcode
5 rs rt Offset 16 bits
opcode
beq rs, rt, Label
bne rs, rt, Label
PCAdd
32
32 3232
32
offset16
32
00
sign-extend
from the low order 16 bits of the branch instruction
branch destinationaddress
?Add
432
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 = goto label• Existe un formato para la instrucción de desvio, el formato tipo j
j Label
FORMATO J
opcode Target address
6 bits 26 bits
Ejemplo: j Label
2 Target address
opcode
SALTOS INCONDICIONALESDirecció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
2 Target address
opcode
PC
4
32
26
32
00
from the low order 26 bits of the jump instruction
j Label
OPERACIONES LOGICAS
Ejemplo:Compilación de la estructura if-then-elseif(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 ExitElse: 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.
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
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 LoopExit: ...
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
0 rs rt rd 0 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
Ejemplo:Compilación de la estructura if-then-elseif(i<j) f=g+h;else f=g-h;
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 FinElse: sub $s0, $s1, $s2 # f = g – h Fin: ...
Solución:Supongamos que el compilador asocia las variables f a j con los registros $s0 a $s4, respectivamente:
Else:
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 bytelh 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 bytelhu rt, offset(rs) # Carga en los 16 LSBits de rt media palabra
# El valor cargado es extendido con 0’s# a 32 bits en rt
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.
15 0 8 10101010101010102
10101010101010102
00000000000000002 11111111111111112
00000000000000002
10101010101010102 11111111111111112
ori $t0, $t0, 0xFFFF
lui $t0, 0xAAAA
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, L2j L1
L2: ……
L1: …
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
Top Related