INTRUCCIONES: LENGUAJE MAQUINA · UNIDAD II 3 ÁREA DE ARQUTIECTURA Y TECNOLOGÍA DE COMPUTADORES...

UNIVERSIDAD DE CORDOBA

ESTRUCTURA DE COMPUTADORES

UNIDAD II

1 ÁREA DE ARQUTIECTURA Y TECNOLOGÍA DE COMPUTADORES

INTRUCCIONES: LENGUAJE MAQUINA

1.- INTRODUCCION

Conceptos importantes

Instrucción: Orden al hardware del

Computador

Repertorio de Instrucciones

Lenguaje Máquina (ML)

Lenguaje Ensamblador (AL)

Lenguaje de Alto Nivel (HLL)



UNIDAD II


Objetivo en el diseño del Repertorio de Instrucciones

Facilitar la implementación hardware

Importante en maquinas actuales

Facilitar el diseño del Compilador

Optimizar el Rendimiento y el Coste

Objetivo de este Capítulo

Considerar un Repertorio de Instrucciones con esos objetivos

Relación entre HLL y AL

Evolución histórica del Repertorio de Instrucciones

Consideraremos el Repertorio de Instrucciones de los Procesadores MIPS



UNIDAD II


2.- OPERACIONES DEL HARDWARE DEL COMPUTADOR

Operaciones Aritméticas

add a, b, c (MIPS)

Notación muy rígida; siempre tres operandos

Ejemplo de suma de 4 valores

add a, b, c

add a, a, d

add a, a, e

Principio UNO de Diseño

“LA SIMPLICIDAD FAVORECE LA REGULARIDAD”



UNIDAD II


Instrucciones MIPS introducidas


Ejemplo 1

HLL:

a = b + c

d = a - e

AL:

add a, b, c

sub d, a, e

Ejemplo 2

HLL:

f = (g + h) - (i + j)

AL:

add t0, g, h

add t1, i, j

sub f, to, t1



UNIDAD II


3.- OPERANDOS DEL HARWARE DEL COMPUTADOR

Solo variables binarias

Almacenadas en Registros

longitud: 32 bits

número limitado: 32 registros ($0, $1,........., $31)

casi de Propósito General

Principio DOS de Diseño: Justificación del uso de Registros

“LO MAS PEQUEÑO ES MAS RAPIDO”


Ejemplo

HLL:

f = (g + h) - (i + j)



UNIDAD II


AL: asignación; f, g, h, i, y j $16, $17, $18, $19 y $20

add $8, $17, $18

add $9, $19, $20

sub $16, $8, $9

$8 y $9 actúan como Registros temporales

Para tratamiento de Estructuras de Datos

Número de Registros pequeño

Almacenamiento en Memoria

Necesidad de Instrucciones de Transferencia de datos

Suministro de la dirección

Carga (Load): M R

lw $R, Puntero ($S) # $R Puntero + $S



UNIDAD II


Almacenar (Store) M R

sw $R, Puntero ($S) # Puntero + $S $R


Ejemplo de CARGA

HLL

g = h + A[i]

AL: asignación g, h, i $17, $18 y $19

dirección de Array Astart

registro temporal: $8

Ejemplo de ALMACENAMIENTO

HLL

A [i] = h + A [i]

lw $8, Astart ($19)

add $17, $18, $8



UNIDAD II


AL

lw $8, Astrat ($19)

add $8, $18, $8

sw $8, Astart ($19)

Existen Instrucciones de transferencia de 8 y 16 bits

Operandos MIPS



UNIDAD II


Instrucciones MIPS introducidas



UNIDAD II


4.- REPRESENTACION DE LAS INSTRUCCIONES EN EL COMPUTADOR

Se representan mediante combinaciones binarias de una longitud fija

ejemplo

add $8, $17, $18

Significado de los campos en la Instrucción de suma

op: código de operación: 6 bits rd: operando destino: 5 bits (Registro)

rs: primer operando fuente: 5 bits (Registro) shamt: desplazamiento (no en esta operación): 5 bits

rt: segundo operando fuente: 5 bits (Registro) funct: variedad de la operación: 6 bits



UNIDAD II


Principio TRES de Diseño:

“UN BUEN DISEÑO DEMANDA COMPROMISOS”

Problemas para Instrucciones que necesitan campos mayores

Instrucciones de carga han de especificar dos registros

Formato I (immediato) en lugar del R (registro)

lw rt, Dirección (rs)

aquí rt es destino



UNIDAD II


Codificación de instrucciones MIPS

el campo primero indica el formato (R ó I)

Ejemplo de codificación de las instrucciones en MIPS

HLL:

A[i] = h + A[i]

AL:

lw $8,1200($19)

add $8,$18,$8

sw $8,1200($19)

OJO: diferencias entre la primera y la tercera sólo en un bit del OPCODE



UNIDAD II


Arquitectura MIPS

revelada



UNIDAD II


5.- INSTRUCCIONES PARA TOMAR DECISIONES

Hecho clave que caracteriza a un computador es la toma de decisiones

Hacer una secuencia u otra en función de

unos valores de entrada

resultados de cálculo

MIPS incluye dos instrucciones de toma de decisiones

Instrucciones de salto condicional

beq R1,R2,L1 # Salta a L1 si es igual

bne R1,R2,L1 # Salta a L1 si no es igual

Ejemplo:

HLL:

If (i == j) goto L1;

f=g+h;

L1: f=f-i;



UNIDAD II


AL: asignación de registros f, g, h, i, j $16,...,$20

beq $19,$20,L1

add $16,$17,$18

L1: sub $16,$16,$19

Ejemplo de bucle:

HLL:

Loop: g = g + A[i];

i = i + j;

if (i != h) goto Loop;

AL: asignación de registros g,h,i,j $17,..., $20

asignación de valor 4 $10 (tamaño 32 bits)

Loop: mult $9,$19,$10

lw $8,Astart($9)

add $17,$17,$8

add $19,$19,$20

bne $19,$18,Loop



UNIDAD II


Ejemplo de while:

HLL:

while (save[i] == k)

i = i + j;

AL:

Loop: mult $9,$19,$10

lw $8,Sstart($9)

bne $8,$21,Exit

add $19,$19,$20

j Loop

Exit: ...



UNIDAD II


Instrucciones para comparación de una variable menor que otra

slt $8,$10,$20

Compara contenido de $19 y $20

si $19 < $20 1 en $8

si $19 >= $20 0 en $8

Como $0 es siempre 0 puede usarse para comparaciones

MIPS no implementa blt (saltar sobre menor que)

Lo implementa con dos instrucciones

slt $1,$16,$17 # $1 a 1 si $16 < $17

bne $1,$0,Less # va a Less si $1 != 0

salta a Less si el contenido de $16 es menor que el de $17

Es preferible dos instrucciones rápidas a complicar todo el hardware con una sola



UNIDAD II


Instrucciones para implementar las sentencias CASE o SWITCH

MIPS incluye una instrucción jr (salto - registro)

Ejemplo:

HLL:

switch(k){

case 0: f = i+j; break; /* k = 0 */

case 1: f = g+h; break; /* k = 1 */

case 2: f = g-h; break; /* k = 2 */

case 3: f = i-j; break; /* k = 3 */

}



UNIDAD II


AL: asignación f,g,h,i,j,k $16, ..., $21

Loop: mult $9,$19,$21 # $9 = k*4

lw $8,Jumptable($9)

jr $8

L0: add $16,$19,$20

j Exit

L1: add $16,$17,$18

j Exit

L2: sub $16,$17,$18

j Exit

L3: sub $16,$19,$20

j Exit

Exit: ...

Jumptable: tabla de dirección de saltos

jr $8: salta a la dirección contenida en el registro $8.



UNIDAD II


Arquitectura MIPS presentada



UNIDAD II


6.- SOPORTAR PROCEDIMIENTOS EN EL HARDWARE DEL COMPUTADOR

Importancia de los procedimientos o subrutinas

Instrucciones que lo permitan

Salto al procedimiento

Retorno a la instrucción siguiente a la llamada

jal procedureAddress “jump and link”

dirección de vuelta en $31: PC+1 $31

para volver: jr $31

Anidamiento de llamadas a procedimiento

$31 almacena en la pila (necesidad de puntero de pila)

dirección de vuelta en $31

Almacenar en Pila (Push)

Sacar de la Pila (Pop)



UNIDAD II


Ejemplo: Un procedimiento A llama al procedimiento B y éste a su vez al C

Puntero de pila usar el $29 y en $24 el valor de ajuste de la pila

A: ...

jal B # Llama al procedimiento B

...

B: ...

add $29, $29, $24 # ajusta la pila

sw $31,0($29) # guarda dirección de vuelta

jal C

...

lw $31,0($29) # restaurar dirección de vuelta

sub $29,$29,$24 # ajustar la pila

...

jr $31

C: ...

jr $31



UNIDAD II




UNIDAD II


Paso de parámetros o argumentos en la llamada

Convenio Software de usar $4, $5, $6 y $7

para parámetros

Si hay mas uso de Pila

Almacenamiento en Pila al anidar llamadas

Políticas sobre modificación de Registros en los

Procedimientos

Guarda Invocador (Caller Save)

Guarda Invocado (called Save)

Política de acelerar llamadas a Procedimientos

Evitar guardar y restaurar Registros

Convenio Software de MIPS

Registros como Invocador guardado

No preservado en la llamada

Registros como Invocado guardado

Preservado en la llamada

Convenio histórico en el manejo de la Pila

Almacenamiento con predecremento del SP

Recuperación con postincremento del SP



UNIDAD II


Arquitectura MIPS revelada



UNIDAD II


7.- OTROS DIRECCIONAMIENTOS

Objetivos suma de constantes (p. ej. 4) a un registro

Rapidez en acceso a ctes pequeñas

Aumentar la eficacia de los saltos

Operando constantes o inmediatos

Gran importancia de estos operandos (ctes).

52% en el compilador gcc

69% en el Spice

Método de acceder a ellos hasta ahora

coger la constante en memoria para utilizarla

lw $24, Dirección constante 4 ($0)

add $29, $29, $24

suma la constante 4 al registro 29



UNIDAD II


Introducción de un direccionamiento inmediato (16bits)

addi $29, $29, 4 # $29 = $29 + 4

formato MIPS de addi

Otras intrucciones con direccionamiento Inmediato

La de inicializar sobre menor que

slti $8, $18, 10 # $8 = 1 si $18 < 10



UNIDAD II


Principio de diseño CUATRO

HACER COMUN EL CASO RAPIDO

Al hacer la constante parte de la instrucción es más rápida

Cargar constantes de valor grande

Tarea del Ensamblador o Compilador

Carga inmediata superior (load upper inmediate)

lui $8, 255 # $8 00ff0000



UNIDAD II


Ejemplo:

Carga la constante 003D0900 en $16

lui $16, 61 # 61 003D(Hex)

addi $16, $16, 2304 # 2304 D900(Hex)

Direccionamientos en saltos y bifurcaciones

Bifurcaciones incondicional o salto (J)

6 bit de opcode y el resto para dirección

J 10000 # salta a la pasición 10000



UNIDAD II


Bifurcación condicional (branch)

6 bit opcode, 10 para dos operando y 16 para dirección

bne $8, $21, Exit # ir a Exit si $8 $21

Problema: salto solo 64K primeros de dirección.

Saltos relativos a un registro

Dirección base en registro más desplazamiento de hasta 216

Útil en bucles.

Saltos relativos al PC

Contenido del PC más desplazamiento de 215

Para direcciones cercanas



UNIDAD II


Salto de bifurcación y bifurcación y enlace

Útil para saltos largos

Posibilidad de salto largos condicionales

Combinar condicional y bifurcación

bne $18, $19, Loop2

J Loop1

Loop2: ......

equivalente a beq $18, $19, Loop1



UNIDAD II


Resumiendo los modos de direccionamiento

vistos:

1. Direccionamientos de registros:

Operando en registros

2. Direccionamiento base o de

desplazamiento.(direccionamiento

indirecto)

Operando en posición de

memoria

3. Direccionamiento inmediato.

Operando immediato constante

en la instrucción

4. Relativos al PC

Dirección PC más constante en

la instrucción.



UNIDAD II


Arquitectura MIPS revelada.



UNIDAD II


8.- ALTERNATIVA A LAS APROXIMACIÓNES DE MIPS

Otras maquinas presentan un repertorio diferente

Proponen:

Más instrucciones

Más complejas o potentes

Consecuencias

Disminuyen el nº de instrucciones de un programa

Lentifica la ejecución de instrucción.

Más ciclos de reloj por instrucción

Ciclos de reloj más lentos

Instrucciones con autoincremento y autodecremento

Acceso a vectores ( Arrays ) de datos



UNIDAD II


Autoincremento

Dos instrucciones (MIPS)

lw $8, Sstart ($19) # $8 start + $19

addi $19, $19, 4 # $19 $19 + 4

Equivalente como autodecremento

lw+ $8, Sstart ($19)



UNIDAD II


Para el autodecremento es similar

Utilidad para acceso a memoria tipo pila

Operandos almacenados en memoria para operaciones

Combinan operaciones de carga con operaciones aritméticas.

Dos instrucciones (MIPS)

lw $8, Astart (19)

add $16, $17, $8

Una sola con operando en memoria

addm $16,$17, Astart ($19)

Inconveniente de que rompa la regularidad

Instrucciones de diferentes tamaños (68000, VAX,…)

Problemas con varios operandos en memoria (muy larga)



UNIDAD II


Operaciones complejas

Busqueda de secuencia de operacciones que se presenten frecuentemente y sustituirla

por una sola

Instrucción que haga todo para llamada a procedimiento

Guarda al PC, registros y ajuste de pila

Instrucción de incremento compara y salta

ejemplo para MIPS

Loop: .......

addi $19, $19, 1 # $19 $19+1

slt $8, $19, $20 # $8 =1 si $19 < $20

bne $8, $0, Loop # irá a Loop si $8 0

en otra máquina

Loop: .......

icb $19, $20, Loop # $19 $19+1 ;

# si $19 < $20 ir a Loop

Habría que hacer con 1, 2, 4 y 8 según el incremento que se genere

se complica ( lentitud)



UNIDAD II


9.- EJEMPLO COMPLETO I

Vamos a ver el código en ensamblador (MIPS) para un procedimiento en C

Procedimiento C: Intercambio de dos posiciones de memoria

swap(in v [ ], int K)

{ int temp;

temp = v [k];

v[k] = v [k+1];

v [k+1]= temp;

}

Traducción al ensamblador: Fases

1) Asignación de registros a las variables

2) Código del cuerpo del procedimiento.

3) Preservar registros en la llamada a procedimiento



UNIDAD II


Asignación del registro

Registro por paso de parametros $4, $5, $6, y $7

Dos parametros V $4 y k$5

Variable temp $15

Código por el cuerpo del procedimiento

Cuerpo

tem = v[k];

v[k] = v [k+1];

v[k+1] = temp;

Traducción:

muli $2, $5, 4 # $2 =k * 4 (op. de 4 bytes)

add $2, $4, $2 # $2 v + 4*k v[k]

lw $15, 0 ($2) # $15 (temp) = v[k]

lw $16, 4 ($2) # $16 = v [k+1]

sw $16, 0 ($2) # v[k] = $16

sw $15, 4 ($2) # v[k+1] = $15 (temp)



UNIDAD II


Preservar los registros de la llamada de procedimiento

Política de guardar el invocado

Se usan $2, $15 y $6

$29 es el puntero de pila

Ajuste de la pila

addi $29, $29, -12 # crece hacia abajo

almacena registros usados

sw $2, 0 ($29)

sw $15, 4 ($29)

sw $16, 8 ($29)

al final se deben restaurar esos registros



UNIDAD II


Código de Ensamblador

MIPS para el

procedimiento SWAP



UNIDAD II


10.- ARRAYS FRENTE A PUNTEROS

Vamos a ver el código fuente y ensamblador de procedimientos que borran una secuencia de

palabras de memoria

Codigo en HLL

Utilizando índice de array

clear 1 (int array [i], int size)

{

int i;

for (i = 0; i < size; i =i+1)

array [i] = 0;

}



UNIDAD II


Utilizando puntero

clear 2 (int * array, int size)

{

int *p;

for (p= & array [?]; p < & array[size]; p=p+1)

*p = 0;

}

Código MIPS

Utilizando un array

Asignación: array y size se asigna a $4, $5; i se asigna a $2

move $2, $0 # i = 0

Loop1: mult $14, $2, 4 # $14 = i*4

add $3, $4, $14 # $3 = array [i] (dirección)

sw $0, 0 ($3) # array[i]=0

addi $2, $2, 1 # i=i+1

slt $6, $2, $5 # $6 = 1 si i < size

bne $6, $0, Loop1 # si i < size va a Loop1



UNIDAD II


Código MIPS

Utilizando punteros

Asignación: array y size se asigna a $4, $5; p se asigna a $2

move $2, $4 # p = direc. de array [0]

Loop2: sw $0, 0 ($2) # memoria [p] = 0

addi $2, $2, $4 # p = p+4

muli $14, $5, 4 # $14 =size*4

add $3, $4, $14 # $3 = direc. de array [size]

slt $6, $2, $3 # $6 = 1 si p < array [size]

bne $6, $0, Loop2 # si $6 = 1 ve a Loop2

El cálculo de los demás array [size] sacado fuera del lazo

move $2, $4

muli $14, $5, 4

add $3, $4, $14

Loop2: sw $0, 0 ($2)

addi $2, $2, 4

slt $6, $2, $3

bne $6, $0, Loop2



UNIDAD II


Los dos códigos generados

move $2,$0 # i=0 move $2,$4 #p=& array[0] Loop1:muli $14,$2,4 #Í14=i*4 muli $14,$5,4 #$14=size*4 add $3,$4,$14 # $3=8 array[i] add $3,$4,$14 #$3=8array[size] sw $0,0($3) #arrayl:i]=0 Loop2: sw $0,0($2) # Memory[p]=0 addi $2,$2,1 # i=i+1 addi $2,$2,4 # p=p+4 slt $6,$2,$5 #$6=<i<size) slt $6,$2,$3 #$6=(p<&array[size]) bne $6,$0,Loop1 # si () ir a Loop1 bne $6,$0, Loop2 # si () ir a Loop2

Por cada iteración

6 Instrucciones en el código de array

4 Instrucciones en el código punteros.



UNIDAD II


11.- COMENTARIOS ADICIONALES

Instrucciones más potentes significan mayor rendimiento

Ejemplo con instrucciones VAX

Llamada a procedimientos en una sola instrucción

Se obtendrá un programa 1,2 veces más rápido que usando llamadas normales.

Escribir en lenguaje ensamblador para obtener mayor rendimiento

Difícil hoy día con los modernos compiladores

Comparación de los Proced. SORT y SWAT

Error al olvidar que la direcciones secuenciadas de las palabras en máquinas con

direccionamiento en bytes no difieren en 1



UNIDAD II


12.- OBSERVACIONES FINALES

Principios del computadora de programa almacenado que les hace de propósito general

Uso de instrucciones, indistinguibles de los números

Uso de memoria alterable por los programas.

Principio que guían a los diseñadores del repertorio de instrucciones

Más pequeño es más rápido

Uso de registros

La simplicidad favorece la regularidad

Instrucciones de único tamaño

Conservar los campos de registro en una misma posición



UNIDAD II


Un buen diseño demanda compromisos

Instrucciones de igual longitud? o constantes y direcciones grandes?

Hacer rápido el caso común

Direccionamiento relativo al PC para saltos

Direccionamiento inmediatamente para constantes

El lenguaje ensamblador

Nivel por encima del código máquina

Fácil de recordar

El ensamblador traduce a código máquina

Puede crear instrucciones simbólicas que no existen

Por ejemplo: almacenar constantes grandes.



UNIDAD II


La instrucciónes MIPS tratadas

Categoría

Correspondencia con LAN (MIL)

Frecuencia en función del programa



UNIDAD II


13.- PERSPECTIVA HISTORICA.

Primeros computadores eran arquitecturas estilo Acumulador

EDSAC (1949)

Costoso del Hardware

Un solo registro que acumulaba resultados; Fuente y destino a la vez

Modo de direccionamiento de operando directo

add 2000 # Acc + (2000) Acc

Ejemplo de traducción de código

Código Fuente

A = B + C;



UNIDAD II


Código Ensamblado

Computadores posteriores con conjuntos de registros dedicados

Cada registro para datos u operación especifica (8086)

Computadores en conjunto de registro de propósito general

Arquitectura registro - memoria (68000, IBM 360)

Admite operando en memoria

Arquitectura registro - registro (MIPS) CDC 6600 (1963)

También conocida por carga- almacenamiento



UNIDAD II


Computadores que permiten todos los operandos en memoria

Arquitectura memoria- memoria (VAX de DEC.1977)

Computadores de arquitectura modelo pila

Los operandos en pila (Hewlett-Packard)

Resolver el problema de una mala asignación de registros

Ejemplo de traducción de código

Código Fuente

A = B + C;

Código

Ensamblado



UNIDAD II


Computadores con instrucciones de diferente longitud

Intel 8086, IBM 360 (2,4, ó 6 bytes), VAX (1 a 54 bytes)

Aprovechar mejor la memoria

Diferentes tipos de Arquitecturas



UNIDAD II


Aparición de arquitectura de computadores de lenguaje de alto nivel

Hacer los lenguajes y los compiladores más eficientes

Filosofía CISC

Aparición de arquitectura RISC ( los ochenta)

Computadores con conjunto de instrucciones reducido

Algo más profundo que solo pocas instrucciones

MIPS, SUN SPARC, Hewlett Packard HPPA

IBM POWER PC DEC ALPHA, etc...

INTRUCCIONES: LENGUAJE MAQUINA · UNIDAD II 3 ÁREA DE ARQUTIECTURA Y TECNOLOGÍA DE COMPUTADORES...

Documents

Transcript of INTRUCCIONES: LENGUAJE MAQUINA · UNIDAD II 3 ÁREA DE ARQUTIECTURA Y TECNOLOGÍA DE COMPUTADORES...