Pr. Dr. Xavier Bonnairebonnaire/download/ARQ_6... · 2006-02-28 · Pr. Dr. Xavier Bonnaire - Universidad Tecnica Federico Santa María – Departamento de Informática SlSliidede

Pr. Dr. Xavier Bonnaire - Universidad Tecnica Federico Santa MarPr. Dr. Xavier Bonnaire - Universidad Tecnica Federico Santa María – Departamento de ía – Departamento de InformáticaInformática

Slide Slide 11

Pr. Dr. Xavier Bonnaire


Slide Slide 22

Temario

● Introducción● Estructura Básica de un Computador● Lenguaje de Máquina Básico● Instrucciones para decisiones● Procedimientos ● Direccionamiento● Assemblers y Linkers


Slide Slide 33

Introducción

● Para programar un computador digital– Se debe usar su propio lenguaje de programación

● Es decir el lenguaje de programación del procesador● El lenguaje de programacion del procesador– La palabras del lenguaje se denominan instrucciones

– El vocabulario se llama el conjunto de instrucciones

● Varios lenguajes– Casi todo los procesadores tienen un conjunto de instrucciones diferente

– Algunos son compatibles (Intel P4 y AMD Athlon, etc...)

● Cada uno tiene instrucciones especiales


Slide Slide 44

Estructura Básica de un Computador

● Un computador digital se compone de 3 grandes bloques– El Procesador– El Sistema de Memoria– El Sistema de Entrada / Salida

● El Procesador es el elemento principal– Se implementa con un Chip VLSI– Está formado por

La Unidad de Control

El Camino de Datos


Slide Slide 55

Estructura de un Computador

Unidadde

Control

Caminode

Datos

MEMORIA

Entrada

Salida

Procesador

Compilador


Slide Slide 66


Unidadde

Control

Caminode

Datos

MEMORIA

Entrada

Salida

Procesador

TarjetaVideo

DiscoDuro

PCI BUS


Slide Slide 77


ProcesadorSocket

PowerConector

Chipset

PCI Slot

AGP Slot

Clock CMOSLi-Ion Bat.

Hard DiskIDE Conectors

RAM Slolts


Slide Slide 88

Procesador Conector


Slide Slide 99

Lenguaje de Máquina Básico

● Consideraremos la máquina MIPS para nuestro estudio– Procesadores R3000 y R4000

● El procesador MIPS tiene 32 bits– Se desarrolló con tecnología RISC

● Su diseño es lo suficientemente general como para entender el lenguaje de máquina de cualquier procesador.– Los procesadores tipo Pentium 4, AMD Athlon XP, etc.. pueden tener un conjunto de instrucciones muchos más grande que el MIPS


Slide Slide 1010

Lenguaje Assembly y de Máquina

● Lenguage Assembly– Una forma de representar las instrucciones y operandos del lenguaje del procesador

– Forma que puede entender el ser humano● Lenguaje de Máquina

– La representacion del lenguaje del procesador al nivel binario

– Una serie de bytes que representan las instrucciones y operandos

● El Assembler– El programa que permite pasar de la forma Assembly a la forma lenguaje de máquina


Slide Slide 1111

Lenguaje de Alto Nivel - Procesador

Lenguaje deAlto Nivel

(C, Java, ...)LenguajeAssembly

LenguajeMáquina

Compilador Assembler

LenguajeMáquina

Ejecutable

LinkerNo depende delProcesador


Slide Slide 1212

Aritmética (Assembly)

● Todo computador debe ser capaz de realizar operaciones aritméticas.

● Sumas y restas en MIPS se realizan de la siguiente manera:

add a,b,c#a ← b + csub a,b,c #a ← b - c

Regla 1 de diseño:Simplicidad → regularidad → desempeño

Oper 1destino

Oper 2 Oper 2


Slide Slide 1313

Ejemplos

Código en C:a=b+c;d=a-e;

Lenguaje de Máquina:add a,b,csub d,a,e

Código en C:f=(g+h)-(i+j) ¿..?


Slide Slide 1414

Operadores y Registros

● A diferencia de los lenguajes de alto nivel– Los operandos de las instrucciones aritméticas no pueden ser variable. Son memorias muy rápidas llamadas registros.

● Un registro de la máquina MIPS tiene 32 bits.

● Un grupo de 32 bits, se denomina palabra (Word)

● Una colección de 32 registros rápidos se denomina Archivo de Registros

● ¿Por qué el archivo de registros tiene sólo 32 registros?

● Lo pequeño es rápido (regla 2 de diseño)


Slide Slide 1515

Operadores y Registros

● La identificación de los registros se puede hacer usando números (del 0 al 31)

● Usaremos $s0, $s1, ..., $sN– Para designar registros que corresponden a variables de programas.

● Usaremos $t0, $t1, ..., $tN– Para designar registros que corresponden a variables temporales.


Slide Slide 1616

Ejemplos

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

add $t0,$s1,$s2 # $t0 ← g+h

add $t1,$s3,$s4 # $t1 ← i+j

sub $s0,$t0,$t1 # f ← $t0-$t1

f g+h i+j


Slide Slide 1717

Tratamiento de Arreglos

● Los lenguajes de programación– Además de manejar variables simple. Son capaces de manipular estructuras más complejas.

● Estructuras de datos como los arreglos, son mantenidos en memoria principal.

● Para llevar una palabra de memoria a un registro se utiliza la instrucción Load Word

lw Reg1, Const(Reg2)Ex: lw $s1, 100($s2)

$s1 = Memory[$s2 + 100]


Slide Slide 1818

Ejemplo

● Compilar “a mano”, la siguiente expresión en C:g=h+A[8];

lw $t0,8($s3) #$t0 ← A[8]add $s1,$s2,$t0 #g ← h+A[8]

ConstanteSegundo registroResultado

Resultado Final hLa dirección de memoria se obtienesumando una constante con el contenidodel segundo registro


Slide Slide 1919

Offset y Registro Base

lw $t8,8($s3)

Registro BaseOffset

La constante en una instrucción de transferencia se denomina offet y elregistro que se le suma para formar la dirección, se denomina registro base


Slide Slide 2020

Restricción de Alineamiento

● La memoria principal está organizada en Bytes.– Esto significa que las direcciones son direcciones de Bytes

● Los procesadores están organizados en registros de 32 bits (palabras)– 32 Bits = 4 Bytes

● La forma de ubicar Bytes en palabras da origen a dos organizaciones distintas

Big Endian (MIPS, Sparc, PowerPC, ...)

Little Endian (Intel Familly, AMD, ...)


Slide Slide 2121

Big Endian y Little Endian

Memoria Big Endian

3 2 1 07 6 5 4

04

0 1 2 34 5 6 7

04

Memoria Little Endian

Direcciónesde palabras

Byte 3 Byte 2 Byte 1 Byte 0

32 Bits

Least Significant ByteMost Significant Byte

Bytes

Bytes Bytes

Bytes


Slide Slide 2222

Ejemplo - Arreglo con variable índice

● Asumir que A tiene 100 elementos. La base está en el registro $s3 y además el compilador asocia las variables:

g ← $s1

h ← $s2

i ← $s4● Se pide el código assembly correspondiente a la sentencia C anterior

g=h+A[i]


Slide Slide 2323

Ejemplo - Solución

● Antes de cargar A[i] en un registro temporal– Se necesita su dirección.– Antes de sumar i a la base del arreglo para generar su dirección, es necesario multiplicar el índice i por 4, debido a la forma de direccionar bytes.

● La multiplicación por dos se puede generar: i+i=2i, 2i+2i=4i, etc..

g=h+A[i]


Slide Slide 2424

Ejemplo - Solución

add $t1,$s4,$s4 #$t1 ← 2*iadd $t1,$t1,$t1 #$t1 ← 4*i

Para obtener la dirección de A[i], necesitamos sumar $t1 con la base de A que está en $s3

add $t1,$t1,$s3 # $t1 ← dirección A[i]con esta dirección se puede cargar A[i] en un registro temporal

lw $t0, 0($t1) # $t0 ← A[i]Finalmente el resultado queda en g:

add $s1,$s2,$t0 # g ← h+ A[i]


Slide Slide 2525

Assembly a Máquina

● La instrucción que se representa en assembly por add $t0,$s1,$s2 en una instrucción de máquina (notación decimal) queda:

OP rs rt rd shamt funct

0 17 18 8 0 32add $s1 $s2 $t0 add

6b 5b 5b 5b 5b 6b

Formato tipo R


Slide Slide 2626

Campos del Formato

● op: código de operación● rs: Primer operando fuente● rt: Segundo operando fuente● rd: Registro destino● shamt: Shift amount (se usa en instrucciones de desplazamiento)

● funct: selecciona una variación específica del código de operación (Código de operación expandido)


Slide Slide 2727

Formato Tipo I (Inmediato)

● Consideremos la instrucción assembly:

lw $t0, 32($s3) # $t0 ← A[8]

OP rs rt dirección

35 17 18 32

6b 5b 5b 16b

lw $s3 $t0

Formato tipo I


Slide Slide 2828

Formato Tipo I (Inmediato)

● Consideremos la instrucción assembly:

sw $t0, 32($s3) # A[8] ← $t0

OP rs rt dirección

43 17 18 32

6b 5b 5b 16b

sw $s3 $t0

Formato tipo I


Slide Slide 2929

Resumen de Formatos

● Es un buen principio de diseño tomar compromisos: – regularidad de formatos y tamaño del código de operación (número de instrucciones)

6 5 5 5 5 6op rs rt rd shamt functop rs rt Dirección

BitsRI


Slide Slide 3030

Pseudo Instrucciones

● Muchas instrucciones Assembly no existen en el Lenguaje de Máquina, pero pueden ser generadas con otras instrucciones. Un ejemplo es la instrucción move que permite copiar un registro en otro. Esta instrucción no existe en la máquina MIPS

● Ejemplo

move $s1,$s2 #$s1 ← $s2

El Assembler MIPS genera:

add $s1,$0,$s2 #$s1 ← $s2+ 0


Slide Slide 3131

Instrucciones para decisiones

● La máquina MIPS presenta dos instrucciones para la toma de decisiones:

● Beq (Branch Equal)

beq reg1, reg2, L1– If (reg1 == reg2) goto L1

● Bne (Branch Not Equal)

bne reg1, reg2, L1– If (reg1 != reg2) goto L1


Slide Slide 3232

Ejemplo 1

● Generar el lenguaje de máquina para el codigo C:

if(i==j) goto L1; f=g+h;

L1: f=f-i;

● Asumir que las 5 variables: f,g,h,i,j; corresponden a los 5 registros: $s0,....,$s5


Slide Slide 3333

Solución

beq $s3,$s4,L1 # if(i==j) goto L1add $s0,$s1,$s2 # f=g+h

L1: sub $s0,$s0,$s3 # f=f-i

L1 representa la dirección de la instrucción de resta


Slide Slide 3434

Ejemplo 2

● Usando las mismas variables y registros del ejemplo anterior, generar código de máquina para

if(i==j) f=g+h;

else f=g-h;


Slide Slide 3535

Solución

● Este ejercicio introduce otro tipo de salto llamado salto incondicional.– La instrucción MIPS se denomina jump y se abrevia j

● J direcciónbne $s3,$s4,Else #if(i!=j)goto Elseadd $s0,$s1,$s2 #f=g+hj Exit #goto Exit

Else: sub $s0, $s1, $s2 #f=g-hExit:


Slide Slide 3636

Saltos Incondicionales

● j Exit #goto Exit● jr $t1 #goto $t1

OP dirección6b 26b

J es del tipo J


0 rs 0 0 0 8

6b 5b 5b 5b 5b 6bJr es del tipo R


Slide Slide 3737

Compilación de Loops

● Compilar el código C:

while (A[i]==k) i=i+j;● Asumiremos que i,j k corresponden a los registros $s3, $s4, y $s5.

● Además la base del arreglo A está guardada en $s6.

● El primer paso es cargar A[i] en un registro temporal:


Slide Slide 3838

Compilación de Loops

Loop: add $t1,$s3,$s3 #$t1=2*iadd $t1,$t1,$t1 #$t1=4*iadd $t1,$t1,$s6 #$t1 es la

dirección de A[i]lw $t0,0($t1) #$t0=A[i]bne $t0,$s5,Exit # ir a Exit si A[i]!= kadd $s3,$s3,$s4 #i=i+jj Loop

Exit:


Slide Slide 3939

Comparaciones

● La máquina MIPS tiene dos instrucciones de comparación:

● slt $s1,$s2,$s3 #set on less than

#if $s2<$s3$s1←1

else $s1←0


Slide Slide 4040

Comparaciones

● Saltar Menor Que: se puede construir:

slt $s1,$s2,$s3 bne $s1,$0, Menos #va a Menos si #$s1←0, o sea si $s2 < $s3● Existe la pseudo instrucción blt (branch less than), pero el compilador genera las dos instrucciones anteriores si encuentra blt


Slide Slide 4141

Ejemplo 3 – El Switch

● Compilar el código C:

switch(k) {case 0: f=i+j; break; //k=0case 1: f=g+h; break; //k=1case 2: f=g-h; break; //k=2case 3: f=i-h; break; //k=3

}● asumiremos que las 6 variables desde f a k, corresponden a los registros $s0 a $s5. El registro $t2 contiene el valor 4


Slide Slide 4242

Switch – Valores de Registros

f ↔ $s0

g ↔ $s1

h ↔ $s2

i ↔ $s3

j ↔ $s4

k ↔ $s5

4 ↔ $t2


Slide Slide 4343

Solución

● Usaremos la variable k para indexar una tabla de salto. El salto se hace vía el valor cargado.

● Lo primero es verificar rangos para kslt $t3,$s5,$0 # ¿k <0?bne $t3,$0,Exit # si k<0, goto Exitslt $t3,$s5,$t2 # ¿k<4?beq $t3,$0,Exit # si k >=4 goto Exit


Slide Slide 4444

Solución

● Hay que multiplicar por 4 el valor de k para convertirlo en dirección de byte

add $t1,$s5,$s5 # $t1=2*kadd $t1,$t1,$t1 # $t1=4*k

● Las direcciones de los códigos correspondientes a los distintos valores de k, se mantienen en una tabla de salto


Slide Slide 4545

Solución

● Asumiremos una secuencia de 4 palabras de memoria, comenzando de la dirección almacenada en $t4. Obtenemos así la dirección de L0, L1,L2 y L3

L0L1L2L3

Tabla de Saltos


Slide Slide 4646

Solución

● Obtención de la dirección de L0, L1,L2 y L3

add $t1,$t1,$t4 #$t1=dirección deTabla Salto [k]

lw $t0,0($t1) #$t0=Tabla Salto[k]


Slide Slide 4747

Solución

● Los primeros tres casos de switch son los parecidos:

jr $t0 #salto basado en registro $t0L0: add $s0,$s3,$s4

j ExitL1: add $s0,$s1,$s2

j ExitL2: sub $s0,$s1,$s2

j Exit


Slide Slide 4848

Solución

● Finalmente:

L3: sub $s0,$s3,$s4Exit:


Slide Slide 4949

Procedimientos

● Los procedimientos o subrutinas son las herramientas más poderosas para estructurar programas.

● En la ejecución de un procedimiento un programa sigue los siguientes pasos:– Poner parámetros en un lugar accesible– Transferir el control al procedimiento– Realizar la tarea– Poner el resultado en lugar accesible– Volver el control al punto original


Slide Slide 5050

Procedimientos

● El software MIPS asigna los siguientes registros a Procedimientos:

● $a0-$a3: Argumentos para el paso de parámetros

● $v0-$v1: Registros para el retorno de valores

● $ra: Dirección de retorno para volver al punto original

● La máquina MIPS incluye la instrucción jal (Jump And Link)

jal DirecciónProcedimiento


Slide Slide 5151

Jal – Jump And Link

● La instrucción

jal DirecciónProcedimiento

● Tiene como efecto saltar a la dirección indicada, pero simultáneamente salva la dirección de retorno en $ra

● La dirección almacenada en $ra se denomina dirección de retorno.

● Esto es necesario ya que el mismo procedimiento puede ser invocado en diferentes partes del programa


Slide Slide 5252

El Program Counter - PC

● Es necesario disponer de un registro que permita almacenar la dirección de la instrucción que está siendo ejecutada.

● Por razones históricas este registro se denomina PC: Program Counter.

● Debería llamarse IAR (Instruction Address Registre).

● La instrucción jal salva PC+4 en el registro $ra para establecer la dirección de retorno


Slide Slide 5353

El Program Counter - PC

InstrPC

Addr 0

PC+4Instrucción en ejecución

Memoria


Slide Slide 5454

Retorno de procedimiento

● La instrucción que permite volver al punto inicial es: jr $ra

instruc1

jr $ra

jal Dir1

ProcedimientoProg. Principal

PC

PC+4

Dir1


Slide Slide 5555

Procedimientos Anidados

● Lo normal en el desarrollo de un programa es que un procedimiento pueda llamar a otro, y que también se pueda llamar a si mismo en forma directa o indirecta (Recursividad)

...Jal B

instb.....jal C;.......jr $ra

inst1.......jr $ra

AB

C


Slide Slide 5656

El Stack

● Es necesario el uso de un stack para permitir flexiblemente usar procedimientos anidados y recursividad

Addr 0

Addr n

Registro sp(Stack Pointer)


Slide Slide 5757

El Stack – Agregar Datos (PUSH)

Addr 0

Addr n

sp

Addr 0

Addr n

sp $s0sp = sp - 4

addi $sp, $sp,-4sw $s0, 0($sp)Add Inmediate


Slide Slide 5858

Código usando Stack

.......jal B;

......

......addi $sp,$sp,-4sw $ra,0($sp)jal C;lw $ra,0($sp)addi $sp,$sp,4.......jr $ra

.......

.......jr $ra

A

B

C


Slide Slide 5959

Direccionamiento

● ¿Dónde ir a buscar un operando? ¿A qué dirección transferir el control del programa?– La Máquina MIPS presenta todos los modos de direccionamiento de las máquinas reales

● Los mecanismos de direccionamiento que estudiaremos son:– Tipo Registro– Operandos Inmediatos– Direccionamientos Absolutos– Direccionamientos relativos al PC– Direccionamiento Registro Base


Slide Slide 6060

Tipo Registro

● Lo más fácil es que el operando se encuentre en un registro. Este es el caso de las instrucciones tipo R.

● Ejemplo: add,$s1,$s2,$s3


0 18 19 17 0 32add $s1 $s2 $s0 add

6b 5b 5b 5b 5b 6b

Formato tipo R


Slide Slide 6161

Operandos Inmediatos

● Estadísticas de programas muestran que el 50% de los operandos son constantes, y estas constantes son números relativamente pequeños.

● Una forma es almacenar las constantes en la memoria principal y recuperar mediante una instrucción lw

● Ejemplo en C: a=a+5;


Slide Slide 6262

Operandos Inmediatos

● Supongamos que el número 5 lo guardamos en la dirección DIREC, y que la variable a la almacenamos en el registro $s1

● Entonces a=a+5 se genera:

lw $t1,DIREC($0)add $s1,$s1,$t1

● ¿Existe una mejor solución?


Slide Slide 6363

Instrucciones Inmediatas: addi

● Una alternativa al código anterior es:

addi $s1,$s1,5

OP rs rt Operando Inmediato

8 rs rt valor

6b 5b 5b 16b

addi

Formato tipo I

Pb: limitación a 16bits para el operando inmediato


Slide Slide 6464

Instrucciones Inmediatas: slti,lui

● Otras instrucciones con operandos inmediatos son:

slti $t1,$s1,5 #Set on Less Than Inmediate)

if($s1<5)$t1=1

● Y

lui $s1,255 #Load Upper Inmediate


Slide Slide 6565

lui

● lui $s1,255 #Load Upper Inmediate

OP rs rt Operando Inmediato6b 5b 5b 16b

255

0000000011111111 000000000000000016 bits lower

menos significativos16 bits upper

más significativos

$S0

$s0


Slide Slide 6666

Direccionamiento Absoluto

● j 1000 # goto 1000

2 10006b 26b

Formato tipo J

El espacio de direcciones alcanzable es de 64MB El código que se genera no es relocalizable


Slide Slide 6767

Direccionamiento Relativo al PC

bne $s1,$s2,Exit # goto Exit si $s1 !=$s2

5 rs($s1)rt($s2) Exit6b 5b 5b 16b

Formato tipo I

El espacio de direcciones alcanzable es de 216 Bytes.

Para aumentar este espacio, se considera que el campode 16bits son direcciones de palabras de 32bits


Slide Slide 6868


PC Limitado por 16 Bits

Memoria


Slide Slide 6969


Ejemplo:a: bne $s2,$s3,FIN add $t4,$s4,$s6 j aFIN:

80000 5 8 21 280004 0 19 20 19 0 3280008 2 8000080012

$s2 ← 8, $s3 ← 21$t4 ← 19, $s6 ← 20a: Dirección 80000


Slide Slide 7070

Resumen Direccionamientos

Tipo Registro


OP rs rt dirección

registro +

Tipo Base

Memoria


Slide Slide 7171


Inmediato

OP rs rt

Relativo al PC

OP rs rt dirección

PC +

Memoria


Slide Slide 7272


OP DirecciónMemoria

Absoluto


Slide Slide 7373

Assemblers y Linkers

● El lenguaje assembly es la representación simbólica de la codificación binaria de un programa.

● El lenguaje assembly tiene directivas que no generan código: .data, .global

● Los roles que tiene el lenguaje assembly son:– Lenguaje intermedio para un compilador– Embedded computers


Slide Slide 7474

Compilacion y Link

Programa Compilador Assembler

LinkerComputador

Lenguaje Assembly

Ejecutable


Slide Slide 7575

¿Conviene programar en Assembly?

● Programar en Assembly tiene varias desventajas:– Específico a una máquina (baja portabilidad)– La relación entre líneas de código de un lenguaje de alto nivel y Assembly se denomina factor de expansión

● Estudios demuestran que un programador escribe el mismo número de líneas de código por día programando en Assembly o programando en un lenguaje de alto nivel.

● Si x es el factor de expansión, la productividad de un Lenguaje de Alto Nivel respecto a Assembly es X


Slide Slide 7676

Pero ...

● A veces es necesario programar en Assembly– Algunas partes de los Sistemas Operativos

● Clock Interruption Routine– Cuando se busca la máxima velocidad posible

● Códigos críticos– Para unos embedded softwares

● Aviones● Autos

– Para Devices Drivers

Documents

Pr. Dr. Xavier Bonnairebonnaire/download/ARQ_6... · 2006-02-28 · Pr. Dr. Xavier Bonnaire - Universidad Tecnica Federico Santa María – Departamento de Informática SlSliidede