Universidad de Talca Facultad de Ingenier´ıa Escuela de ... · macio´n y seleccio´n de...

Universidad de Talca

Facultad de Ingenierıa

Escuela de Ingenierıa Civil en

Computacion

Arquitectura de Computadores II

Prof: Per Bj. BroSemestre II, 2007October 11, 2007

Syllabus

Objetives

El objetivo fundamental del curso es desarrollar en los alumnos competencias basicas en progra-macion y seleccion de microprocesadores en base a su arquitectura.

Los objetivos especıficos son:

1. Entender la relacion entre lenguaje de alto nivel y ensamblador

2. Entender la relacion entre el conjunto de instrucciones y el camino de datos y control delmicroprocesador

3. Entender la utilidad de segmentacion para aumentar prestacion

4. Entender el uso de jerarquıas de memoria

5. Poder programar un procesador AVR de 8 bits

6. Poder programar un procesador PPC de 64 bits

7. Poder programar un multiprocesador PS3

Los topicos inciales generales se aplican al MIPS procesador de 32 bits, uno de los primeros proce-sadores RISC. Hoy versiones mas nuevas del procesador se encuentran en dispositivos de comuni-caciones y otros sistemas embutidos. La arquitectura del conjunto de instrucciones de MIPS secompara con las arquitecturas de AVR y de PPC.

Prerequisites

Students should have the following abilities before taking this course:

1. Write a program in C language under Linux on an x86

2. Understand how a basic ALU and registers work

i

Results

Al finalizar el curso, los estudiantes deberıan ser capaces de:

1. Translate a program from C to MIPS assembly language

2. Follow the execution of a MIPS machine language instruction

3. Explain why pipelining is more efficient than single stage processing

4. Explain how memory hierarchies contribute to system performance

5. Write a program in C for an AVR or PS3

Grades

The final grade is determined by three tests during the term.

Exam 1 33% 27 September ISA del MIPSExam 2 33% 01 November Segmentacion, memoriasExam 3 34% 06 December Codificacion en AVR, PS3Make-up exam 13 DecemberOptional exam 33% 20 December Cumulativo

ii


Calender

Fecha Materia Referencia23 August Introduction to the course

1 28 August GCC / Instruction Set Architectures2 30 August ISA MIPS 2000, instrucctiones R,I3 04 September Implementacion de condiciones y saltos4 06 September Punteros y arreglos5 11 September Funciones y el stack6 13 September Carga y enlace de programas

18 September —— feriado20 September —— feriado25 September Repaso27 September Control 1

7 02 October Componentes del camino de datos8 04 October Integracion de componentes9 09 October Control camino simple10 11 Octuber Implementacion multiciclo11 16 October Segmentacion

18 October Segmentacion12 23 October Memoria cache13 25 October Memoria virtual

30 October Repaso01 November Control 206 November Arquitectura del PS308 November ISA PPC13 November Programacion del PS315 November Programacion del PS320 November Arquitectura AVR22 November ISA AVR27 November Programacion del AVR29 November Programacion del AVR04 December Repaso06 December Control 313 December Control Recuperativo20 December Control Optativo Cumulativo

iii

Contents

1 ALU’s 1

1.1 Complemento a dos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1

1.2 Construccion de una ALU . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

1.3 Multiplicacion en hardware . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

1.4 Representacion de punto flotante . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

2 Instruction Set Architectures 7

2.1 Compilacion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

2.2 Compilacion cruzada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

2.3 SPIM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

2.4 Ejemplos de codigo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

2.4.1 MIPS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

2.4.2 M-Core . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

2.4.3 M68k . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

2.4.4 x86 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

3 ISA MIPS 13

3.1 Instrucciones ADD, SUB, ADDI . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

3.2 Instrucciones LW, SW . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

v

CONTENTS

3.3 Representacion de instrucciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

3.3.1 Registros MIPS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

4 Loops and Jumps 17

4.1 Instrucciones J, JR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

4.2 Tablas de direcciones de saltos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

4.3 Instrucciones BEQ, BNE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

4.4 Instruccion SLT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

4.5 Modos de Direccionamiento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

5 Arrays and pointers 23

5.1 Arreglos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

5.2 Punteros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

5.3 Decodificacion del programa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

5.4 Listado de instrucciones MIPS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

6 Stack management 27

6.1 Funciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

6.1.1 Pasos para llamar a una funcion . . . . . . . . . . . . . . . . . . . . . . . . 27

6.2 Stack . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

6.3 Compilacion de una funcion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

6.4 Uso de ’fp’ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

6.4.1 Funciones anidadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

7 Linking and loading 33

7.1 Enlace de archivos objeto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

vi


7.2 Compilacion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

7.3 Formatos binarios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

7.4 Enlace . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

7.5 Carga . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38

8 Instruction formats 41

8.1 Carga de instrucciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

8.2 Ejecucion de instrucciones tipo ’R’ . . . . . . . . . . . . . . . . . . . . . . . . . . . 42

8.3 Ejecucion de instrucciones de acceso a memoria . . . . . . . . . . . . . . . . . . . . 43

8.4 Ejecucion de bifurcaciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

9 Single cycle implementation 45

9.1 Integracion de instrucciones ’R’ + load / store . . . . . . . . . . . . . . . . . . . . 45

9.2 Integracion de busqueda de instruccion . . . . . . . . . . . . . . . . . . . . . . . . . 46

9.3 Control de la ALU . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

9.4 El camino de datos y control . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47

10 Multicyle implementation 49

10.1 Ineficiencia del ciclo unico . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49

10.2 Implementacion multiciclo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

10.3 Etapas de ejecucion de una instruccion . . . . . . . . . . . . . . . . . . . . . . . . . 51

10.4 Senales de control multiciclo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52

11 Pipelining 53

11.1 Segmentacion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53

11.2 Camino de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56

vii

CONTENTS

11.3 Fallas y burbujas en segmentacion . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

11.4 Supersegmentacion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61

12 Cache memory 65

12.1 Memory hierarchies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65

12.2 Cache Memory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66

12.3 Associative caches . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68

12.4 Multilevel Caches . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69

13 Memoria Virtual 71

13.1 Physical and virtual addresses . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71

14 Cell Broadband Engine 75

14.1 Architecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75

14.2 Programming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78

15 Atmel AVR 79

15.1 Architecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79

15.2 Programming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80

viii

Chapter 1

ALU’s

Objetivo

• Recordar aritmetica complemento a dos

• Saber como implementar punto flotante

• Recordar como armar una ALU

• Entender como implementar multiplicacion en circuitos

Referencia

Computer Organization & Design, Patterson & Hennessy, Cap. 4.5-4.6

1.1 Complemento a dos

La motivacion de la representacion de numeros con signo (positivos y negativos) es poder utilizar elmismo circuito para las restas y para las sumas. La representacion signo-magnitud tiene el problemaque sumar un numero con su negacion (por ejemplo, sumar 5 con -5) no da como resultado el ceroque uno espera. Si utilizamos cuatro bits para la magnitud y un bit para el signo, este ejemplo es:

0 0 1 0 1 51 0 1 0 1 -51 1 0 1 0 -10

A diferencia de la representacion signo-magnitud, complemento a dos permite sumar numerosnegativos con positivos dando el valor que corresponde. Complemento a dos requiere un bit para

1

ALU’s

el signo, exactamente igual que la representacion signo-magnitud, pero la magnitud se representade otra manera. En complemento a dos un numero positivo se representa de exactamente la mismamanera que el binario normal (signo-magnitud), con un cero para el signo.

Un numero negativo tiene otra representacion. El signo es indicado con un uno. Para representarla magnitud de un numero negativo se siguen estos pasos:

1. Representar la magnitud del numero en binario

2. Complementar la magnitud. Esto significa cambiar los unos por ceros y los ceros por unos.

3. Sumar el valor uno a resultado del complemento.

Ilustramos el proceso con unos ejemplos de conversion a complemento a dos:

+1 0 0001invertir 1 1110

+1comp. dos 1 1111

+5 0 0101invertir 1 1010

+1comp. dos 1 1011

+7 0 0111invertir 1 1000

+1comp. dos 1 1001

+8 0 1000invertir 1 0111

+1comp. dos 1 1000

+15 0 1111invertir 1 0000

+1comp. dos 1 0001

+0 0 0000invertir 1 1111

+1comp. dos 0 0000

Notese que es necesario saber cuantos bits hay para representar el numero. Una forma alternativade calcular el valor de un numero negativo representado en complemento a dos es restar dos elevadoa la potencia correspondiente al bit del signo de la magnitud calculado de la forma normal, ilustradoen este ejemplo:−510 = 110112 = (−1 ∗ 24) + (1 ∗ 23) + (0 ∗ 22) + (1 ∗ 21) + (1 ∗ 20)= −16 + 8 + 0 + 2 + 1 = −16 + 5 = −5 QED

Ahora, ilustramos la misma suma que se hizo en el ejemplo anterior, pero ahora utilizando larepresentacion complemento a dos:

0 0 1 0 1 51 1 0 1 1 -50 0 0 0 0 0

Ası con numeros en representacion complemento a dos, el mismo circuito que realiza las sumas enla ALU puede tambien efectuar las restas. La conversion de numeros a complemento a dos es muyrapido y simple implementar en hardware.El ultimo punto a considerar aquı referente a complemento a dos es un circuito dentro del micro-procesador que se utiliza cuando es necesarios cargar un numero corto, de pocos bits, a un registromas largo. Por ejemplo, es comun tener un constante en complemento a dos de 16 bits que tieneque cargarse a un registro de 32 bits. Los 16 bits adicionales simplemente se rellenan con el valordel bit del signo del numero corto; si el numero es negativo se rellenan con unos, si el positivo serellenan con ceros.

2


1.2 Construccion de una ALU

Construccion de una ALU de un bit con las funciones AND, OR y sumar requiere el uso de unmultiplexor o selector de datos para elegir la funcion deseada. Todas las operaciones se realizan,pero sus resultados pasan por el multiplexor, y solo un valor sale del circuito. Esto es ilustradoen Figura 1.1. Notese que el acarreo saliente es calculado y presente a la salida para todos lasfunciones, no solo al seleccionar sumar con el multiplexor.

b

0

2

Result

Operation

a

1

CarryIn

CarryOut

Figure 1.1: ALU con sumas y restas

Para extender la funcionalidad de la ALU para aceptar numeros en complemento a dos y permitirrestas, se agrega una lınea de control a la entrada B de la ALU para un multiplexor que seleccionasi la segunda entrada a la ALU sera B o la negacion de B. En Figura 1.2 esta lınea es indicada conel nombre ’Binvert’. Adicionalmente, la entrada acarreo entrante se pone en uno, por lo menos enel bit menos significativo de una ALU de multiples bits. Esto se justifica mediante la expresion:a + b + 1 = a + (b + 1) = a + (−b) = a − b

0

2

Result

Operation

a

1

CarryIn

CarryOut

0

1

Binvert

b

Figure 1.2: ALU con complemento a dos

El motivo por lo cual esta conversion a complemento a dos se aplica solamente a la entrada B dela ALU es que esta operacion se efectua unicamente sobre los constantes en las expresiones, quevan a entrar a la ALU por la entrada B. La entrada A a la ALU recibe valores solamente desderegistros, ya expresados en complemento a dos.

3

ALU’s

Para armar una ALU de multiples bits, la manera conceptualmente mas simple es conectar elacarreo saliente de cada bit al acarreo entrante del bit siguiente. Un problema con esta estructurade ALU es que cada operacion no puede iniciar hasta que la operacion anterior haya determinadoel acarreo. Si se desea una ALU mas rapida, se puede calcular independientemente, con circuitosexternos, el acarreo para permitir que cada modulo de un bit empiece mas temprano.

Una ALU requiere funcionalidad mayor que las ilustradas hasta ahora. Tiene que poder indicar siun operando es mayor que el otro, o si son iguales. Para detectar si los dos operandos son iguales seselecciona la operacion para restar un operando del otro; si son iguales, el resultado debe ser cero.Se agrega como salida un NOR con entradas de todas los resultados (despues del multiplexor) delas ALUs. Esta lınea de salida tiene el valor uno si todas los resultados son cero y un cero si porlo menos un resultado es igual a uno.Es mas complicado determinar si un operando es menor que el otro. Si la condicion es verdadero,la salida debe ser uno, sino debe ser cero. En este caso, todos los bits del resultado deben ser ceros,salvo el bit menos significativo, que sera cero o uno de acuerdo al resulado de la condicion. Si A esmenor que B, entonces A-B da un numero negativo. Sin importar la magnitud del resultado, el bitmas significativo va a estar igual a uno en este caso. En el caso contrario, sera cero. Entonces loque se desea para implementar la funcion es crear una nueva entrada para cada modulo de un bit dela ALU. Esta entrada va a estar conectado permanentemente a cero para todas los modulos salvopara el bit menos significativo. La entrada al bit menos significativo estara conectado a la salidadel resultado del bit mas significativo como si fuera retroalimentacion. Entonces, para concluireste punto, el multiplexor tiene ahora cuatro opciones; AND, OR, suma/resta y menor que. Losmodulos de cada bit de la ALU tiene las funciones logicas y aritmeticas correspondientes, ademasde una entrada para menor, que es diferente para el bit menos significativo.

Lo que se ha descrito hasta ahora son ALU’s relativemente simples. En procesadores reales, esnecesario considerar varias otras funciones, tales como el uso de numeros reales, expresiones logicas,multiplicacon y division. Las siguientes secciones describen someramente la forma de incluir estosrequerimientos en una ALU.

1.3 Multiplicacion en hardware

Multiplicar es mas complicado que sumar. Es conveniente realizar un ejemplo de una multiplicacionsimple para analizar los algoritmos para implementar multiplicacion. Los numeros parecen serbinarios, pero perfectamente podrıan ser decimales.

1 0 0 10 1 1 11 0 0 1

1 0 0 11 0 0 1

0 0 0 00 1 1 1 1 1 1

Nota que el proceso es una secuencia de operaciones copiado el multiplicando y desplazandolo unbit a la izquierda en cada iteracion.

4


Su realizacion en hardware utiliza el hecho que el desplazamiento en una columna equivale amultiplicar por dos. Si el bit del multiplicador (segundo operando) es uno, entonces se suma elvalor del multiplicando al producto. El multiplicando se desplaza una columna a la izquierdadespues de cada operacion, y el multiplicador se deplaza un bit a la derecha. Un ejemplo de undiagrama de bloques de un multiplicador se ilustra en Figure 1.3.

64-bit ALU

Control test

MultiplierShift right

ProductWrite

MultiplicandShift left

64 bits

64 bits

32 bits

Figure 1.3: Diagrama de bloques: multiplicacion

En software, si se puede expresar multiplaciones por deplazamientos el programa va a ser masrapido. Por ejemplo:(A ∗ 4) = (A << 2)(A ∗ 5) = (A << 2) + A

(A ∗ 6) = (A << 2) + (A << 1)El analisis de los algoritmos de realizacion de multiplicacion y division es parte de la forma de mejo-ramiento de la prestacion de los procesadores. La multiplicacion es complicado para implementaren hardware. Cuanto mas complejo cuando se evalua la mismo con punto flotante.

1.4 Representacion de punto flotante

Un computador de proposito general tiene que poder manejar numeros reales, que no son enteros.En la jerga computacional estos son los numero de punto flotante, y se representan en formatocientıfico, con exponente y significando. Para sistemas de 32 bits, el formato IEEE estandarespecifica un bit para el signo del significando, ocho bits para el valor del exponente y 23 bits parael valor del significando. El exponente de 8 bits puede representar 256 diferentes valores. Parapoder expresar numeros pequenos tanto como grandes, es necesario tener exponentes negativos. Elestandar IEEE para numeros de 32 bits especifica que se displaza el valor del exponente por 127y entonces representa exponentes desde 2−127 hasta 2128. El ordenamiento de los tres campos delestandar y la especificacion del desplazamiento son para facilitar clasificacion de numeros puntoflotante.El procedimiento para realizar sumas en punto flotante incluye un conjunto de pasos. Primero,se tienen que igualar la precision de los exponentes. Esto se hace desplazando el significandodel numero menor hasta que su exponente sea igual al numero mayor. Despues se suman lossignificandos. La suma se normaliza, desplazando el significando hasta que tenga un solo uno a laizquierda del punto binario (punto decimal). Al normalizar el significando, se tiene que verificarque el exponente no sea demasiado grande ni chico para la representacion en 8 bits. Finalmentese tiene que redondear el valor de significando. Una ALU para realizar sumas en punto flotante seilustra en Figura 1.4.La complicacion de esta ALU en comparasion con una ALU para numeros enteros es motivo de lacreacion de hardware dedicado a procesos de punto flotante, y la existencia de muchos compiladoressimples que no incluyen soporte para punto flotante. En consideracion de la complejidad de esta

5

ALU’s

0 10 1 0 1

Control

Small ALU

Big ALU

Sign Exponent Significand Sign Exponent Significand

Exponent difference

Shift right

Shift left or right

Rounding hardware

Sign Exponent Significand

Increment or decrement

0 10 1

Shift smaller number right

Compare exponents

Add

Normalize

Round

Figure 1.4: ALU para sumas en punto flotante

ALU y en consecuencia el tiempo que necesita realizar calculos en punto flotante es que uno debepensar cuidadosamente si puede obviar el uso de punto flotante en sus aplicaciones. Graficosrequieren mucho calculo de punto flotante, por ejemplo.

Ejercicios

1. Convertir 710 y −710 a complemento a dos utilizando 4 bits, 8 bits y 10 bits.

2. Ilustrar (−7) + (−13) y 7 + (−13) utilizando complemento a dos.

3. Investigar la abstraccion generar y propagar en la aceleracion de determinacion de acarreo,y como se puede mejorar la prestacion de una ALU de esta manera.

4. Calcula el rango de numero que se puede representar en punto flotante.

5. Que ventaja para clasificacion presenta la representacion de exponentes desplazadas a difer-encia de exponentes en representacion complemento a dos.

6. Realiza el seguimiento del multiplicando, multiplicador, y producto durante la multiplicacionde 00102 ∗ 00112

6

Chapter 2

Instruction Set Architectures

Objetivo

• Poder utilizar GCC para generar codigo para diferentes maquinas

• Poder utilizar SPIM para simular programas MIPS

Referencias

Computer Organization & Design, Patterson & Hennessy, Capıtulo 1.3, Apendice Ahttp://en.wikipedia.org/wiki/Compilerhttp://gcc.gnu.orghttp://www.kegel.com/crosstoolhttp://www.cs.wisc.edu/ larus/spim.html

2.1 Compilacion

Se supone que los estudiantes de esta asignatura saben lo que significa compilar codigo. Sin em-bargo, vale la pena, mirar de cerca el proceso porque tiene mucho que ver con la materia de estaasignatura, el lenguaje ensamblador. El proceso de compilacion es la traduccion de un programaen lenguaje fuente de alto nivel a un lenguaje objeto de bajo nivel para posteriormente incorporarel codigo objeto a un programa ejecutable. Aquı, nos interesa el formato de las instrucciones deensamblador generadas, mas que la forma de analizar, interpretar y optimizar las sentencias decodigo fuente. En una asignatura sobre lenguajes de programacion, es muy normal que los estudi-antes tengan que escribir los analizadores lexicograficos y sintacticos para generar un compilador.Por eso, nuestros ejemplos de codigo van a ser muy simples.Se puede considerar que el compilador genera codigo ensamblador, y que el ensamblador gen-era codigo binario. Frecuentemente los compiladores y IDE’s esconden estos pasos e inclusivehace pensar que la compilacion resulta en el programa ejecutable directamente. Triste el alumno

7


que termina esta asignatura con esa creencia aun vigente. Las instrucciones nativas (no seu-doinstrucciones) en ensamblador tienen una equivalencia directa con codigo binario; conociendola instruccion en ensamblador se puede buscar el codigo binario en una tabla sin necesidad deinterpretarla. Normalmente, el codigo binario generado por el ensamblador no es ejecutable direc-tamente, porque es necesario resolver direcciones y funciones de biblioteca tales como el famoso’printf’. Este paso es realizado por el enlazador, o linkeador.El formato de las instrucciones en ensamblador tiene que cooincidir exactamente con la arquitec-tura del microprocesador blanco (target) de la compilacion. Por ejemplo, un micro puede tenerregistros de uso especial o de uso general. Puede tener ciertos circuitos para realizar compara-ciones o operaciones aritmeticas. El ensamblador tiene que tomar en cuenta esta estructura. Espor eso que frecuentamente el disenador de un microprocesador primero decide que instruccionesen ensamblador quiere soportar, y despues disena los circuitos para soportar esa funcionalidad.

2.2 Compilacion cruzada

En las paginas siguientes se ilustra el resultado de la compilacion de un codigo trivial para dosmicroprocesodores RISC (MIPS y M-Core) y dos microprocesadores CISC (M68000 y Pentium).Se sugiere notar la regularidad de la sintaxis del codigo RISC en comparacion con el codigo CISC.El punto es porque y para que hay diferencias entre un codigo y otro.Estos ejemplos fueron generados con el compilador GCC que puede instalarse para una multitudde diferentes blancos (targets). En una maquina tipo PC se pueden instalar GCC para diferentesblancos. La instalacion misma es un proceso lento, porque la compilacion del compilador es lento.Sin embargo, es un proceso que merece experimentarse para aprender y comprender que es uncompilador. Adicionalmente, la capacidad de generar programas para diferentes arquitecturas esde cierto valor en el mundo actual; abre puertas a aplicaciones que van mucho mas alla que softwarepara PC’s.El primer paso para la instalacion del gcc es bajar e instalar el conjunto de herramientas ’binutils’.Binutils contiene el ensamblador ’as’, el enlazador ’ld’, y otros utilitarios como ’objcopy’ paratraducir codigo binario de un formato a otro, y ’objdump’ para desplegar el cdigo e informacionacerca el programa. Objdump puede tomar codigo binario y mostrar el lenguaje ensamblador quelo genero. El segundo paso es la instalacion del glibc para la arquitectura deseada. Una vez queglibc esta instalado, se puede compilar el gcc mismo, utilizando el glibc recientemente instalado.Para cada uno de estos pasos, la secuencia es ’configure’, ’make’, y finalmente ’make install’. Setiene que especificar el directorio donde uno desea dejar los ejecutables, y la arquitectura en cadapaso. El sitio www.kegel.com contiene un script para realizar todos estos pasos con una minimade intervencion del usuario.

2.3 SPIM

Un simulador es un programa que ejecuta codigo destinado a ser ejecutado en otra maquina. El usotıpico de un simulador es para sistemas embutidos para evitar el paso de la carga del ejecutable enel segundo equipo. Ası como un depurador permite ejecutar el codigo en un ambiente controlado,tambien el simulador lo permite. El objetivo es poder examinar los estados de los registros ymemoria en cualquier momento.

El simulador SPIM es para los equipos MIPS. Su entrada es un programa en ensamblador MIPS

8


que podrıa haber sido generado con gcc utilizando la opcion -S para dejar el codigo en lenguajeensamblador. La instalacion es simple, con solo el detalle de controlar el directorio donde se deja elarchivo ’exceptions.s’. Cuando se ejecuta spim, se nota que hay unas instrucciones que se ejecutanantes de saltar a la funcion main. Primero se carga la direccion contenido en el $sp al registro $a0.Despues se suma cuatro a esa direccion y lo deja en $a1. El registro $a2 recibe ese mismo valorincrementado en cuatro mas. Se multiplica el valor en registro $a0 por cuatro y lo deja en registro$v0. Antes de saltar a main, se incrementa $a2 por $v0.El valor del SPIM para esta asignatura es poder visualizar el estado del stack y los registrosdurante la ejecucion de un programa. El manejo del stack, que es de importancia fundamentalpara programadores de sistema, se cubre con detalle mas adelante en la asignatura. Se pretendeque uno sepa utilizar SPIM antes de llegar a ese punto.

9


2.4 Ejemplos de codigo

int main(void) {

printf("Hola, mundo\n");

return(0);

}

2.4.1 MIPS

.file 1 "b.c"

.rdata

.align 2

$LC0:

.ascii "Hola, mundo\n\000"

.text

.align 2

.globl main

.ent main

main:

.frame $fp,24,$31

.mask 0xc0000000,-4

.fmask 0x00000000,0

addiu $sp,$sp,-24

sw $31,20($sp)

sw $fp,16($sp)

move $fp,$sp

la $4,$LC0

jal printf

move $2,$0

move $sp,$fp

lw $31,20($sp)

lw $fp,16($sp)

addiu $sp,$sp,24

j $31

.end main

2.4.2 M-Core

.file "b.c"

.section .rodata

.align 2

.LC0:

.string "Hola, mundo\n"

.text

.align 1

.export main

.type main, @function

main:

subi sp,8

stw r15,(sp)

stw r8,(sp,4)

mov r8,sp

lrw r7, .LC0

mov r2,r7

jbsr printf

movi r7,0

mov r2,r7

mov sp,r8

ldw r15,(sp)

ldw r8,(sp,4)

addi sp,8

jmp r15

.size main, .-main

.ident "GCC: (GNU) 3.4.1"

10


2.4.3 M68k

#NO_APP

.file "b.c"

.section .rodata

.LC0:


.text

.align 2

.globl main


main:

link.w %a6,#0

pea .LC0

jbsr printf

addq.l #4,%sp

clr.l %d0

unlk %a6

rts

.size main, .-main

.ident "GCC: (GNU) 3.4.1"

2.4.4 x86

.file "b.c"

.section .rodata

.LC0:


.text

.globl main


main:

pushl %ebp

movl %esp, %ebp

subl $8, %esp

andl $-16, %esp

movl $0, %eax

subl %eax, %esp

subl $12, %esp

pushl $.LC0

call printf

addl $16, %esp

movl $0, %eax

leave

ret

.size main, .-main

.section .note.GNU-stack,"",@progbits

.ident "GCC: (GNU) 3.3.3 20040412

(Red Hat Linux 3.3.3-7)"

Ejercicios

1. Que porcentaje de los microprocesadores que se fabrican anualmente son para PC’s? Unopuede decir que sean compatibles con las lıneas x86 de Intel, por ejemplo.

2. Que valor tiene esa fraccion del mercado?

3. Que diferencia hay entre la VM de Java y un compilador C ?

4. Existe diferencias entre el codigo de maquina generada por un compilador de lenguaje C yun compilador de lenguaje C++ ?

5. Porque son diferentes los codigos para x86, MIPS, M-Core, si el programa fuente es el mismo?

6. Cual es mas eficaz, disenar un microprocesador para un lenguaje determinado, o disenar unlenguaje para una arquitectura definida ? ’Compatibilidad’ de los x86 incide en el diseno dellenguaje de los Pentium o en el diseno de los Pentium para ese lenguaje ?

7. Consiguese una maquina con Linux e instalar GCC para una arquitectura que te podrıainteresar. Que son las caracterısticas de esa arquitectura?

8. Realiza el seguimiento de un programa corto (por ejemplo, b.s) por SPIM para visualizar losvalores en los registros. Como trata SPIM la funcion ’printf’?

11


12

Chapter 3

ISA MIPS

Objetivo

• Entender las instrucciones add, sub, lw, sw

• Ilustrar representacion de instrucciones R, I

• Listar los registros del microprocesador

Referencias

Computer Organization & Design, Patterson & Hennessy, Cap. 3.3 - 3.4http://cum.unex.es/profes/profes/jlguisado/

3.1 Instrucciones ADD, SUB, ADDI

Las instrucciones add y sub realizan las operaciones sobre los valores almacenados en los registrosindicados por el segundo y tercer operando, dejando el resultado en el registro indicado por elprimer operando. Estas operaciones son de 32 bits, sobre numeros de complemento a dos. Elresultado tambien es complemento a dos.

add t0, t1, t2 # t0 = t1 + t2

sub t0, t1, t2 # t0 = t1 - t2

El formato de estas instrucciones es conocido como ’R’ o de registro, porque los operandos sonsolamente los tres registros. Al final de estas paginas hay una nomina de los registros que seutilizan en las instrucciones MIPS.

13

ISA MIPS

La instruccion addi es parecida a add y sub, pero suma un constante al valor almacenado en unregistro. El resultado se deja en otro registro.

addi t0, t1, 99 # t0 = t1 + 99

addi t0, t1, -99 # t0 = t1 + (-99)

El formato de las instruccion es conocido como ’inmediato’ o ’I’ porque uno de los operandos (elconstante) se encuentra en la instruccion misma a diferencia de las instrucciones ’R’ en que el valordel operando no esta en la instruccion, pero en el registro especificado en la instruccion.

3.2 Instrucciones LW, SW

Las instrucciones de lw y sw tambien son de formato ’I’. Son la unica manera de acceder a memoriaen las maquinas conocidas como RISC.

lw t0, k(t1) # cargar el valor en t1[k] de memoria al registro t0

sw t0, k(t1) # almacenar el valor t0 a t1[k]. ’k’ es expresado en bytes

a = b + c[i];

c[i] = d;

Para representar estas instrucciones en lenguaje ensamblador se requiere el uso de un conjuntode registros. El compilador asigna variables y valores especiales a registros. Cada registro puedealmacenar 4 bytes; en el MIPS R2000, hay 32 registros.

###############en ensamblador MIPS#############

# s0 - a

# s1 - b

# s2 - c

# t0 - &c[i]

# t1 - i

# t2 - c[i]

# t3 - d

add t1, t1, t1 # t1 = 2*i

add t1, t1, t1 # t1 = 4*i

add t0, t1, s2 # t0 = 4*i + c

lw t2, 0(t0) # t2 = *(0+t0)

add s0, s1, t2

sw t3, 0(t0) # *(0+t0) = t3

############### ############### ###############

14


3.3 Representacion de instrucciones

Instrucciones en ensamblador tienen una representacion directa con codigos en binario. Estoscodigos tienen un formato que incluye un conjunto de campos, y cada campo significa algo es-pecıfico. Para el caso de una instruccion tipo ’R’ el formato tiene seis campos:

Campo Tamano Significadoop 6 Codigo de operacionrs 5 Registro de origenrt 5 Registro de origen / destinord 5 Registro de destino

shamt 5 Shift amountfn 6 Funcion

El campo ’shmt’ (shift amount) se utiliza para multiplicaciones, y para otras sentencias es cero.Codificacion de la sentencia:add t0, t1, t2

###############codificacion MIPS#############

# t0 - 8

# t1 - 9

# t2 - 10

# add - opcode 0

# - funcion 32

op rs rt rd shamt funcionsource1 source2 dest. shift amt funcion

decimal 0 9 10 8 0 32n bits 6 5 5 5 5 6binario 000000 01001 01010 01000 00000 100000

Para el caso de una instruccion tipo inmediato o ’I’, el formato es distinto, porque tiene unicamentedos registros, pero tiene que representar el constante.lw t0, 32(t1)addi t0, t1, 44

lw op rs rt direcciondecimal 35 9 8 32n bits 6 5 5 16binario 100011 01001 01000 0000000000100000addi op rs rt direccion

decimal 8 9 8 44n bits 6 5 5 16binario 001000 01001 01000 0000000000101100

15

ISA MIPS

Para el caso de las instrucciones de formato ’I’ es conveniente recordar que el campo para elconstante es de 16 bits, pero tiene que sumarse con un numero de 32 bits. Por ello es necesarioque el signo sea extendido a 32 bits.Instruccion tipo op rs rt rd shamt funcion direccion

add R 0 reg reg reg 0 32 -sub R 0 reg reg reg 0 34 -addi I 8 reg reg - - - constantelw I 35 reg reg - - - constantesw I 43 reg reg - - - constante

3.3.1 Registros MIPS

Los registros en la lista corresponden a registros de almacenamiento fisicamente presentes en elmicroprocesador, a diferencia de memoria o memoria cache que no esta en el microprocesadormismo. Memoria cache esta cerca el micro, e inclusive en la misma chip, sin embargo los registrosestan dentro del mismo camino de datos y representan los lugares de acceso mas rapido.

Nombre Nro Uso salvadozero 0 constante 0 siat 1 acumulacion de nros de 32 bits no

v0-v1 2-3 resultados de funciones y expresiones noa0-a3 4-7 argumentos a funciones not0-t7 8-15 registros temporarios nos0-s7 16-23 registros guardados sit8-t9 24-25 registros temporarios nok0-k1 26-27 reservado para el SO nogp 28 puntero a datos globales sisp 29 puntero al stack sifp 30 puntero al base del stack sira 31 direccion de retorno si

Ejercicios

1. Crear un programa muy simple en C, y traducirlo a ensamblador.

2. Crear un programa con un arreglo en C, pero sin bucles, y traducirlo a ensamblador.

3. Practicar traduciendo instrucciones de ensamblador a binario.

16

Chapter 4

Loops and Jumps

Objetivo

• Ilustrar instrucciones j, jr

• Ilustrar como representar la sentencia ’switch’

• Indicar los modos de direccionamiento de memoria

• Ilustrar instrucciones bne, beq y slt

• Ilustrar como representar todas las condiciones mediante estas instrucciones

Referencia

Computer Organization & Design, Patterson & Hennessy, Cap. 3.3 - 3.6

4.1 Instrucciones J, JR

La instruccion j es un salto del programa a una direccion. Conceptualmente es el mal-famado’GoTo’. La direccion de destino se contiene en un campo de 26 bits, que significa que si sola nopuede direccionar toda la memoria del procesador (232 bits). Para poder extender el rango delos saltos, se supone que el programa solo va a saltar a direcciones de inicio de instrucciones queson de 4 bytes de largo, lo que significa que puede obviar los 2 bits menos significativos, pudiendodireccionar hasta 28 bits. Los 4 bits faltantes se toman de los 4 bits mas significativos del PC,contador de programa, lo que significa que el programa puede saltar a una instruccion dentro de228 bits del valor en el PC.

En el codigo a continuacion, la direccion (’L1’) es una etiqueta asociada con una lınea de codigo.

17

Loops and Jumps

j L1 # goto L1;

###############ejemplo ensamblador MIPS#############

beq t0, t1, ETIQ

add t2, t3, t4

j L2

ETIQ: sub t2, t2, t0

L2: add t2, t2, t0

############### ############### ###############

Instruccion tipo op etiquetan bits 6 26

j J 2 direccion de etiqueta

La instruccion JR salta a la direccion almacenada en el registro ’rs’.

Instruccion tipo op rs rt rd shamt funcionn bits 6 5 5 5 5 6

jr R 0 reg 0 0 0 8

18


4.2 Tablas de direcciones de saltos

############### ############### ###############

switch(k) {

case 0: a = b + c; break;

case 1: a = b - c; break;

case 2: a = c - b; break;

case 3: a = 0; break;

}

############### ############### ###############

# s0 = k

# s1 = a

# s2 = b

# s3 = c

# s4 = 4

# s5 = k*4, indice de la tabla de direcciones

# t0 = condicional

# t1 = valor en JumpTable[k]

# t4 = direccion de base de un arreglo en memoria

# con las direcciones de las etiquetas L0-L3

############### ############### ###############

slt t0, s0, zero # if (k < 0) t0 = 1

bne t0, zero, FIN # if (t0 != 0) goto FIN

slt t0, s0, s4 # if (k < 4) t0 = 1

beq t0, zero, FIN # if (t0 == 0) goto FIN

add s5, s0, s0 # s5 = k + k

add s5, s5, s5 # s5 = k + k + k + k

add s5, s5, t4 # s5 = 4*k + address of jump table

# = direccion de JumpTable[k]

lw t1, 0(s5) # t1 = JumpTable[k], la direccion

# de una etiqueta

jr t1 # saltar a la direccion en t1

L0: add s1, s2, s3 # a = b + c

j FIN

L1: sub s1, s2, s3 # a = b - c

j FIN

L2: sub s1, s3, s2 # a = c - b

j FIN

L3: add s1, zero, zero # a = 0 + 0

FIN: # j FIN es innecesario

############### ############### ###############

19

Loops and Jumps

4.3 Instrucciones BEQ, BNE

Las instrucciones beq y bne son bifurcaciones condicionales. Si la condicion expresada en la in-struccion se cumple, entonces el salto se realiza. Mediante estas instrucciones se implementa elcodigo if (condition) then ... else ....

beq t0, t1, t2 # if (t1 == t2) goto t0

if (i == j) goto ETIQ;

k = m + n;

ETIQ: k = k - i;


# t0 - i

# t1 - j

# t2 - k

# t3 - m

# t4 - n

beq t0, t1, ETIQ

add t2, t3, t4

ETIQ: sub t2, t2, t0

############### ############### ###############

En las instrucciones de formato ’I’, no existe el campo ’rd’. Los campos son operacion, rs, rt, y unconstante. Con instrucciones de este formato, el registro de destino es el registro ’rt’. El primeroregistro en la instruccion (’rs’) es la origen, y el segundo (’rt’) es el destino. Por lo tanto, parainterpretar (decodificar) esta instruccion, el procesador necesita un multiplexor para determinar siva a tomar el registro de destino desde el campo ’rd’, o del campo ’rt’.Instruccion tipo op rs rt etiqueta

n bits 6 5 5 16beq I 4 reg reg constantebne I 5 reg reg constante

4.4 Instruccion SLT

La instruccion slt es parecida a las bifurcaciones condicionales, pero no realiza un salto, simplementemodifica el valor de un registro. Para realizar un salto con slt se asigna el valor al registro y despuesse realiza un salto condicionado en el valor de ese registro.

slt t0, t1, t2 # if (t1 < t2) t0 = 1; else t0 = 0

ETIQ: i = i + k;

k = m + n;

if (i < j) goto ETIQ;

20



# t0 - i < j

# t1 - i

# t2 - j

# t3 - k

# t4 - m

# t5 - n

# el registro ’zero’ contiene el valor 0

ETIQ: add t1, t1, t3

add t3, t4, t5

slt t0, t1, t2

beq t0, zero, ETIQ

############### ############### ###############

i = 0;

do {

j = k+2;

}

while (i < 10);

k = 0;


# t0 - i

# t1 - j

# t2 - k

# t3 - i < 10

# t4 - 10

# t5 - 2

add t0, zero, zero

L1: add t1, t2, t5

slt t3, t0, t4

beq t3, zero, L1

add t2, zero, zero

4.5 Modos de Direccionamiento

Registro Los operandos son registros, por ejemplo, ’add r1, r2, r3’. Se estan direccionando losregistros.

Base o desplazamiento Se direcciona memoria en una posicion de un desplazamiento (con-stante) a partir de una direccion contenido en un registro.

Inmediato Un constante dentro de la misma instruccion. Por ejemplo ’add r1, r2, k’. Si serequiere cargar un constante de 32 bits a un registro, se utiliza la instruccion lui r0, k, ’loadupper immediate’, donde k es un constante de 16 bits que se cargan a los 16 bits superioresdel registro r0. Entonces se le suman 16 bits con la instruccion addi t0, t0, k2.

21

Loops and Jumps

PC relativo Bifurcaciones condicionales direccionan a ubicaciones en codigo relativas a la posicionactual del contador de programa. El formato de la instruccion es tambien inmediata e implicaque el constante es de 16 bits, por lo que la posicion direccionada tiene que encontrarse dentrode s16 bytes del PC. Debido a que el PC se incrementa tempranamente en la decodificacionde la instruccion el desplazamiento es desde { PC + 4 }.

Salto absoluto / seudo-directo La direccion consta de 26 bits contenidos en la instruccionconcadenados con los 6 bits mas significativos del PC.

22

Chapter 5

Arrays and pointers

Objetivo

• Ilustrar la diferencia entre el uso de puntos y arreglos con indicess

Referencia

Patterson and Hennesey (1997), Computer Organization and Design, 2nd Edition, Morgan Kauff-man, Capıtulo 3.11

5.1 Arreglos

void clear(int array[], int size) {

int i;

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

array[i] = 0;

}

//////////////////////////////////

# t0 - i

# a0 - array

# a1 - size

add t0, zero, zero # i = 0

loop1: add t1, t0, t0 # t1 = i*2

add t1, t1, t1 # t1 = i*4

add t2, a0, t1 # t2 = &array[i]

sw zero, 0(t2) # array[i] = 0

23

Arrays and pointers

addi t0, t0, 1 # i = i + 1

slt t3, t0, a1 # t3 = (i < size)

bne t3, zero, loop1 # if (i < size) goto loop1

5.2 Punteros

En la misma funcion implementada con punteros se puede calcular la direccion de finalizacionafuera del bucle, lo que permite que el bucle sea un poco mas eficiente.

void clear(int *array, int size) {

int *p;

for (p = &array[0]; p < &array[size]; ++p) {

*p = 0;

}

//////////////////////////////////

# t0 - p

# a0 - array

# a1 - size

add t0, a0, zero # p = &array[0]

add t1, a1, a1 # t1 = size*2

add t1, t1, t1 # t1 = size*4

add t2, a0, t1 # t2 = &array[size]

L1: sw zero, 0(t0) # mem[p] = 0

addi t0, t0, 4 # p = p + 4

slt t3, t0, t2 # t3 = (p < &array[size])

bne t3, zero, L1 # if (p < &array[size]) goto L1

5.3 Decodificacion del programa

En la decodificacion del codigo es conveniente recordar que las bifurcaciones a direcciones relativasal PC se realizan con pasos de palabras, no bytes. Tambien son relativas al valor del PC+4, osea la instruccion siguiente. Las instrucciones de saltos absolutos (j, jal) tambien utilizan pasos depalabra, no byte, aunque el destino del salto es una direccion absoluto en codigo.

24


add t0, a0, zero0 4 0 8 0 32

add t1, a1, a10 5 5 9 0 32

add t1, t1, t10 9 9 9 0 32

add t2, a0, t10 4 9 10 0 32

L1:sw zero, 0(t0)43 8 0 0

addi t0, t0, 48 8 8 4

slt t3, t0, t20 8 10 11 0 42

bne t3, zero, L15 11 0 -4

5.4 Listado de instrucciones MIPS

Nombre Form. 6 5 5 5 5 6 Comentarioadd R 0 2 3 1 0 32 add 1, 2, 3sub R 0 2 3 1 0 34 sub 1, 2, 3

addi I 8 2 1 100 addi 1, 2, 100addu R 0 2 3 1 0 33 addu 1, 2, 3subu R 0 2 3 1 0 35 subu 1, 2, 3

addiu I 9 2 1 100 addiu 1, 2, 100and R 0 2 3 1 0 36 and 1, 2, 3

or R 0 2 3 1 0 37 or 1, 2, 3andi I 12 2 1 100 andi 1, 2, 100

ori I 13 2 1 100 ori 1, 2, 100sll R 0 0 2 1 10 0 sll 1, 2, 10srl R 0 0 2 1 10 2 srl 1, 2, 10lw I 35 2 1 100 lw 1, 100(2)sw I 43 2 1 100 sw 1, 100(2)lui I 15 0 1 100 lui 1, 100

beq I 4 1 2 25 beq 1, 2, 100bne I 5 1 2 25 bne 1, 2, 100slt R 0 2 3 1 0 42 slt, 1, 2, 3slti I 10 2 1 100 slti 1, 2, 100sltu R 0 2 3 1 0 43 mult 2, 3sltiu I 11 2 1 100 sltiu 1, 2, 100

j J 2 2500 j 10000jr R 0 31 0 0 0 8 jr 31

jal J 3 2500 jal 10000

25

Arrays and pointers

Nombre Nro Uso salvadozero 0 0x00 constante 0 siat 1 0x01 acumulacion de nros de 32 bits no

v0-v1 2-3 0x02-0x03 resultados de funciones noa0-a3 4-7 0x04-0x07 argumentos a funciones not0-t7 8-15 0x08-0xFF registros temporarios nos0-s7 16-23 0x10-0x17 registros guardados sit8-t9 24-25 0x18-0x19 registros temporarios nok0-k1 26-27 0x1A-0x1B reservado para el SO no

gp 28 0x1B puntero a datos globales sisp 29 0x1C puntero al stack sifp 30 0x1D puntero al base del stack sira 31 0x1E direccion de retorno si

Ejercicios

1. Disenar un multiplexor para interpretar el campo funcion de las instrucciones formato ’R’.

2. Disenar un circuito para deshabilitar el multiplexor si la instruccion no es de formato ’R’.Notese que las sentencias de formato ’R’ que nosotros hemos visto todos tienen el campocodigo de operacion igual a cero.

26

Chapter 6

Stack management

Objetivo

• Describir el manejo del stack y funciones en ensambaldor MIPS

Referencia

Patterson and Hennesey (1997), Computer Organization and Design, 2nd Edition, Morgan Kauff-man, Capıtulo 3.6, 3.9

6.1 Funciones

6.1.1 Pasos para llamar a una funcion

Para llamar a una funcion es necesario cuidarse de no perder el punto desde donde se le estallamando y de guardar las variables con que se estaba trabajando. Los pasos escenciales son:

1. Guardar parametros para la llamada

2. Transferir control a la funcion

3. Asignar espacio para las variables locales de la funcion

4. Ejecutar la funcion

5. Guardar el resultado de la funcion

6. Regresar el control a la instruccion posterior de la llamada

27

Stack management

Para realizar estas operaciones se utilizan los siguientes registros:

• $a0-$a4: espacio para guardar 4 parametros

• $v0-$v1: registros en que se devuelve el resultado de la funcion

• $ra: registro para guardar la direccion de retorno

La instruccion jal Address guarda la direccion de retorno en registro $ra, y coloca la direccion de lafuncion en el PC. La instruccion jr $ra coloca en el PC la direccion que se encuentra en el registro$ra.

6.2 Stack

Cuando se requiere mas que cuatro registros para guardar los parametros de la llamada, y paraguardar los valores de la variables locales a la funcion, se utiliza una estructura dinamica enmemoria llamada el stack (pila), una cola tipo LIFO. La pila es una zona en memoria que crececuando se le agrega otro elemento y decrece cuando un elemento es removido. Estas operacionesse llaman ’push’ y ’pop’ respectivemente. El corcho de una botella de champana tambien hace’pop’ cuando sale. Los elementos siempre se agregan y remuevan desde un extremo, extremo quese considera como el lado superior, aunque no ha motivo fundamental por lo cual considerar queuna direccion es superior a otra.

Hay un registro de uso especıficia para apuntar al punto superior del stack, llamado el puntero delstack, ’sp’. El ’sp’ contiene la direccion del elemento encima del stack. Tipicamente el stack crecedesde arriba hacia abajo, ası que el elemento superior tiene la direccion mas baja de los elementosdel stack.

Ası que para guardar un registro en el stack, es necesario decrementar el ’sp’ y mover la variablea la direccion del ’sp en memoria. Expresado mas correctamente, se decrementa el valor almace-nado en el registro ’sp’. En muchas arquitecturas de conjuntos de instrucciones hay instruccionesexplıcitas para ’push’ y ’pop’ variables del stack, sin embargo en la arquitectura MIPS se utilizanlas instrucciones ’lw’ y ’sw’, y la modificacion explıcita del ’sp’.

Otro registro utilizado en el manejo del stack es el ’fp’ (frame pointer). El ’fp’ apunta a la direcciondonde los registros de la actual funcion empiezan en el stack. El espacio entre el ’sp’ y el ’fp’ sellama un ’frame’, o marco, y es allı donde todas las variables locales a una funcion y sus parametrosse guardan. Es mas conveniente utilizar el ’fp’ que el ’sp’ para acceder a las variables locales deuna funcion porque se sabe que los parametros siempre estan a 0, 4, 8 y 12 bytes abajo del ’fp’,mientras desde el ’sp’ estan a distancias variables.

6.3 Compilacion de una funcion

La compilacion de este fragmento de codigo C :

28


.

.

.

a = fn(b, c, d, e);

.

.

.

int fn(int b, int c, int d, int e) {

int f;

f = (b + c) - (d + c);

return(f);

}

.

.

.

da el siguiente codigo ensamblador, suponiendo que las variables b, c, d, y e se encuentran enlos registros t0, t1, t2, y t3 respectivemente. Notese que los valores en estos registros tienen queguardarse para que no sean modificados durante al ejecucion de la funcion.

add a0, zero, t0 # cargar los parametros de la llamada

add a1, zero, t1

add a2, zero, t2

add a3, zero, t3

jal fn # guardar PC+4 en el registro ra

.

.

.

fn:

subi sp, sp, 12 # ajustar el sp para las 3 variables locales

sw t1, 8(sp) # salvar los registros t0, t1 y s0 que

sw t0, 4(sp) # se utilizan localmente en la suma

sw s0, 0(sp)

add t0, a0, a1 # t0 = b + c

add t1, a2, a3 # t1 = d + e

sub s0, t0, t1 # s0 = t0 - t1

add v0, s0, zero # retornar el resultado en v0

lw s0, 0(sp) # reestablecer los registros locales

lw t0, 4(sp)

lw t1, 8(sp)

add sp, sp, 12 # regresar el sp a su valor original

jr ra # saltar al punto de llamada

Una convencion utilizado en codigo MIPS es de suponer que los registros t0-t9 pueden utilizarselibremente para variables locales en funciones sin preocuparse para guardar y recuperar sus valores

29

Stack management

originales. Si una funcion utiliza los registros s0-s7, la funcion debe guardar y recuperar sus valoresoriginales. Por lo tanto, en el codigo ilustrado, el haber salvado y recuperado los registros t0 y t1no habrıa sido necesario.

6.4 Uso de ’fp’

.file 1 "a.c"

.text

.align 2

.globl main

.ent main

main:

.frame $fp,16,$31

# vars= 8, regs= 1/0, args= 0, gp= 0

.mask 0x40000000,-8

.fmask 0x00000000,0

addiu $sp,$sp,-16

sw $fp,8($sp)

move $fp,$sp

sw $0,0($fp)

$L2:

lw $2,0($fp)

slt $2,$2,3

beq $2,$0,$L3

lw $2,0($fp)

sw $2,4($fp)

j $L2

$L3:

move $sp,$fp

lw $fp,8($sp)

addiu $sp,$sp,16

j $31

.end main

6.4.1 Funciones anidadas

Cuando una funcion llama a otra, se tiene que salvar los valores de los registros ’ra’, ’sp’ y ’fp’ademas que los registros s0-s7. Esto es el caso de una funcion recursiva, tanto como no-recursiva.

int fact(int n) {

if (n < 1)

return(1);

return(n * fact(n-1);

}

//////////////////////////

30


fact:

sub sp, sp, 8 # hacer espacio en el stack para 2 variables

sw ra, 4(sp) # guardar ra en el stack

sw a0, 0(sp) # guardar a0 tambien

slt t0, a0, 1 # probar el valor del parametro

beq t0, zero, L1 # continuar si no a0 !< 1

add v0, zero, 1 # incrementar el valor de retorno en 1

add sp, sp, 8 # recuperar el stack

jr ra # volver al lugar de donde fue llamado

L1: sub a0, a0, 1 # decrementar n

jal fact # llamar a fact

lw a0, 0(sp) # aqui regresamos despues de la llamada

lw ra, 4(sp) # recuperamos a0 y sp

add sp, sp, 8 # recuperamos el stack utilizado

mul v0, a0, v0 # hacer la multiplicacion

jr ra # y volver

Otras formas de codificar tambien guardan el ’fp’ sobre el stack cuando se realiza una llamada auna funcion.

Ejercicios

1. Utilizar SPIM para hacer el seguimiento de los registros sp y fp durante y despues de llamadasa funciones.

2. Investigar la diferencia de velocidad de acceso a memoria RAM y acceso a registros en unprocesador moderno de arquitectura x86.

3. Disenar una esquema para pasar ocho parametros en registros, sin tener que utilizar memoria.Calcula la diferencia en velocidad al usar registros a diferencia de stack.

31

Stack management

32

Chapter 7

Linking and loading

Objetivo

• Detallar el procedimiento para ensamblar, enlazar y cargar programas

Referencias

Patterson and Hennesey (1997), Computer Organization and Design, 2nd Edition, Morgan Kauff-man, Capıtulo 3.6, 3.9http://en.wikipedia.orghttp://linuxgazette.net/issue84/hawk.html

7.1 Enlace de archivos objeto

El codigo ’ProcA’ llama al codigo ’ProcB’ y utiliza datos que se encuentran en el archivo ’ProcB’.A continuacion se ilustra una simplificacion de la informacion contenida en 2 archivos objetos sonmutuamente relacionados.

ProcB incluye una llamada a ProcA, y tambien referencia las variables externas x1 y x2 delsegmento de datos de ProcA. A su vez, ProcB define los datos y1 y y2 referenciadas en ProcA.

33

Linking and loading

Encabezadonombre ProcAsizeText 0x200sizeData 0x20

Text segment direccion instruccion0 add t2, a0, t14 lw zero, 0(gp)8 jal ProcB12 lw zero, 0(gp)... ...

Datos0 x14 x2... ...

Reubicacion4 lw / y18 jal / ProcB12 lw / y2

Sımbolos etiqueta direccionProcA text:0x1 data:0x2 data:4ProcB ?y1 ?y2 ?

Encabezadonombre ProcBsizeText 0x800sizeData 0x12

Text segment direccion instruccion0 add t2, a0, t14 lw zero, 0(gp)8 jal ProcA12 lw zero, 0(gp)... ...

Datos0 y14 y2... ...

Reubicacion4 lw / x18 jal / ProcA12 lw / x2

Sımbolos etiqueta direccionProcB text:0y1 data:0y2 data:4ProcA ?x1 ?x2 ?

34


El enlazador ubica los segmentos de los diferentes archivos en memoria. Otra tarea del enlazador esrecorrer las tablas de sımbolos sin definicion de los archivos objeto, para encontrar las referenciasexternas que no fueron resueltas en la etapa de compilacion y ensamble del archivo objeto. Enel ejemplo, junta el texto ProcA y ProcB en un segmento que tendra 0xA00 bytes de largo y elsegmento de datos que tendra 0x32 bytes de largo.

Supongamos que el texto empieza en la direccion 0x1000, los datos estaticos en 0x2000, y que elregistro ’gp’ del MIPS apunta a la direccion 0x2800. Si el texto ProcB viene antes que ProcA,entonces ProcB esta en la direccion 0x1000, y ProcA esta en 0x1800. Si los datos de ProcA vienenprimero entonces estan a partir de la direccion 0x2000 y los de ProcB estan a partir de 0x2020.

Notese que el desplazamiento desde el registro ’gp’ esta en complemento a 2 para 16 bits. Elregistro ’gp’ esta en 0x2800 y hay una referencia al dato ’y2’ en la direccion 0x2024. Entonces ladiferencia es 0x07DC negativo que equivale a 0xF824 en complementao a 2 para 16 bits.

Otro detalle es la traduccion a binario de las instrucciones ’jal’. En ensamblador, se refiere a ladireccion absoluta del destino del salto en bytes, pero en la codificacion en binario los saltos seexpresan en palabras, por lo tanto, el salto a 0x1800 serıa un salto a 0x0600 en binario y el saltoa 0x1000 serıa un salto a la direccion 0x400.

EncabezadosizeText 0xA00sizeData 0x32

Text segment direccion instruccion0x1000 add t2, a0, t10x1004 lw zero, 0xF800(gp)0x1008 jal 0x18000x100C lw zero, 0xF804(gp)... ...0x1800 add t2, a0, t10x1804 lw zero, 0xF820(gp)0x1808 jal 0x10000x180C lw zero, 0xF824(gp)

Datos0x2000 x10x2004 x2... ...0x2020 y10x2024 y2

7.2 Compilacion

La compilacion del programa codigo fuente traduce este a codigo en lenguaje ensamblador. Unasentencia en ensamblador tiene una correspondencia directa con codigo binario, y el conjunto desentencias binarios forman el archivo binario o objeto. Pero unicamente el formato mas simplees solamente un conjunto de instrucciones en binario. Un archivo objeto tiene que entregar unconjunto de datos para el sistema operativo, o kernel que lo va a ejecutar. Hay muchos formatosque un archivo binario puede tener, su popularidad ha cambiado a traves del tiempo y ha sido

35

Linking and loading

causal de ’jihad’. Entonces el ensamblador tiene que generar un formato que el enlazador puedeutilizar para generar el ejecutable. Antes de describir la tarea del enlazador, se mencionan losformatos binarios en uso.

7.3 Formatos binarios

Un formato de archivos ejecutables utilizado en CP/M y MS-DOS se lama COM. COM es unarchivo binario que se carga siempre a la direccion 0x0100 de un segmento y ejecutado allı. Elejecutable tiene un tamano maximo de 0xff00 (65.280) bytes, o sea 0xffff - (0x0100 - 0x0001).El formato COM y su contemporaneo MS-EXE, presentaba limitantes para un sistema operativocon pretenciones de ser multi-tarea y con memoria virtual. En el mundo Unix, el formato tradicionalde archivos ejecutables se llama a.out. Un archivo de formato a.out tiene la siguiente estructura:

struct exec

{

unsigned long a_info; /* Use macros N_MAGIC, etc for access */

unsigned a_text; /* length of text, in bytes */

unsigned a_data; /* length of data, in bytes */

unsigned a_bss; /* length of uninitialized data area for file, in bytes */

unsigned a_syms; /* length of symbol table data in file, in bytes */

unsigned a_entry; /* start address */

unsigned a_trsize; /* length of relocation info for text, in bytes */

unsigned a_drsize; /* length of relocation info for data, in bytes */

};

Los campos de la estructura representan secciones del archivo ejecutable, salvo a info, y a entry.El primer campo, a info indica el tipo del ejecutable; el campo a entry es la direccion inicial delprograma que fue 0x0100 para el formato COM.El formato COFF (Common Object File Format) fue disenado para permitir un numero mayor desecciones. Fue introducido con SVR3, pero duro poco, reemplazandose por ELF (Executable andLinking Format).

Microsoft utiliza el formato PE (Portable Executable), una modificacion de COFF, a partir deWindows NT 3.1. PE contiene secciones para texto (codigo ejecutable), datos (datos globales) yuna IAT (import address table). La tabla IAT se utiliza cuando la aplicacion realiza una llamadaa una funcion de la API de Windows. Recuerda que una llamada a una funcion del SO quieredecir un salto a una direccion, en este caso una direccion dentro del SO, o de un modulo de unalibrerıa dinamica. Cuando un modulo dinamica es cargado a memoria, se carga a la IAT un saltoa las direcciones de las funciones del modulo.

PE es utilizado por el sistema operativo ReactOS, SkyOS y BeOS. Posteriormente SkyOS y BeOScambiaron por ELF. ELF es el formato actual utilizado en el mundo de los Unices. Se acompanaen el mundo GNU por un BFD (binary file descriptor library) para proveer una interfaz entre losdiferentes formatos.

El encabezado ELF tiene un formato descrito por un conjunto de estructuras de datos. Una de-scripcion (demasiada) completa se obtiene ejecutando el comando ’man elf’. Estas estructuras

36


contienen informacion para archivos binarios que sea reubicable (relocatable), ejecutable o com-partido (shared object, dynamic link library).

typedef struct

{

unsigned char e_ident[EI_NIDENT]; /* Magic number and other info */

Elf32_Half e_type; /* Object file type */

Elf32_Half e_machine; /* Architecture */

Elf32_Word e_version; /* Object file version */

Elf32_Addr e_entry; /* Entry point virtual address */

Elf32_Off e_phoff; /* Program header table file offset */

Elf32_Off e_shoff; /* Section header table file offset */

Elf32_Word e_flags; /* Processor-specific flags */

Elf32_Half e_ehsize; /* ELF header size in bytes */

Elf32_Half e_phentsize; /* Program header table entry size */

Elf32_Half e_phnum; /* Program header table entry count */

Elf32_Half e_shentsize; /* Section header table entry size */

Elf32_Half e_shnum; /* Section header table entry count */

Elf32_Half e_shstrndx; /* Section header string table index */

} Elf32_Ehdr;

7.4 Enlace

El enlazador, o linker, une los diferentes archivos objeto que conjuntamente forman el ejecutablefinal. Estos archivos objetos contienen codigo de maquina, e informacion para el enlazador. Estainformacion son referencias a sımbolos locales que deben estar disponible para otras modulos, ytambien referencias a sımbolos en modulos externos. Las referencias externas tienen que resolverseen un proceso que se llama ’resolucion’ de la direccion.En sistemas con enlace dinamico, la resolucion de direcciones en modulos puede postergarse hastael momento de ejecucion, para poder compartir el codigo de ciertas funciones entre diferentesprocesos. La ventaja del objeto compartido, o librerıa dinamica, es que se reduce la cantidadde memoria necesaria si multiples programas utilizan un solo modulo, y se permite actualizacioneficiente de funciones, sin tener que reinstalar todas las aplicaciones que utilizan la funcion areemplazarse. Una desventaja de las librerıas dinamicas, tanto en Linux como Windows, es queuna aplicacion puede instalar una librerıa que invalida la version anterior y ası corrumpir otrasaplicaciones.

El enlazador:

1. Ubica simbolicamente los modulos de texto y datos en memoria

2. Determina las direcciones de las referencias absolutas.

3. Modifica las referencias externas a otros modulos y las direcciones absolutas.

4. Crea el archivo ejecutable con las referencias modificadas.

37

Linking and loading

7.5 Carga

El sistema operativo lee el archivo ejecutable producido por el enlazador.

1. Asigna un espacio en memoria para el texto y datos

2. Copia las instrucciones y datos del archivo a memoria

3. Copia los parametros en la llamada del programa al stack

4. Inicializa los registros de la maquina y asigna el ’sp’ a la primera direccion en memoria libre

5. Salta a una rutina de inicializacion para copiar los parametros a registros y llama la rutinaprincipal del programa.

Si el programador utilizando gcc desea proveer sus propias rutinas de inicializacion entonces debepasar el parametro ’-nostartfiles’ al compilador / enlazador. Notese que esta opcion es usadoparticularmente en aplicaciones embutidas, y sin el sistema operativo, donde es necesario realizarla inicializacion en forma manual. La rutina de inicializacion tipicamente se llama ’ start’. Sufuncion es de cargar los parametros en la llamada al programa al stack, inicializar los registros yllamar a la funcion main.

Si el programa de aplicacion utiliza rutinas de una librerıa dinamica, entonces el enlazador no vaa saber en que direccion va a encontrarse es rutina. Se deja un salto a la direccion almacenada enla tabla de funciones con direcciones no resueltos. En el momento de carga del programa se llenanla tabla con las direcciones actuales.

A continuacion se ilustra la salida del ’objdump -S’ para un programa compilado con informacionde depuracion pero sin los archivos de inicializacion.

int j=999;

int i=888;

j = 777;

i = 666;

for (i=0; i < 555; ++i)

j = 1;

return(444);

********************************************

a: file format elf32-littlemips

Disassembly of section .text:

00400018 <main>:

int j = 999;

38


int main(int argc, char *argv[]) {

400018: 27bdfff0 addiu sp,sp,-16

40001c: afbe0008 sw s8,8(sp)

400020: 03a0f021 move s8,sp

400024: afc40010 sw a0,16(s8)

400028: afc50014 sw a1,20(s8)

int i = 888;

40002c: 24020378 li v0,888

400030: afc20000 sw v0,0(s8)

j = 777;

400034: 24020309 li v0,777

400038: af828008 sw v0,-32760(gp)

i = 666;

40003c: 2402029a li v0,666

400040: afc20000 sw v0,0(s8)

for (i = 0; i < 555; ++i) {

400044: afc00000 sw zero,0(s8)

400048: 8fc20000 lw v0,0(s8)

40004c: 00000000 nop

400050: 2842022b slti v0,v0,555

400054: 1040000a beqz v0,400080 <main+0x68>

400058: 00000000 nop

j = i;

40005c: 8fc20000 lw v0,0(s8)

400060: 00000000 nop

400064: af828008 sw v0,-32760(gp)

400068: 8fc20000 lw v0,0(s8)

40006c: 00000000 nop

400070: 24420001 addiu v0,v0,1

400074: afc20000 sw v0,0(s8)

400078: 08100012 j 400048 <main+0x30>

40007c: 00000000 nop

}

return(444);

400080: 240201bc li v0,444

}

400084: 03c0e821 move sp,s8

400088: 8fbe0008 lw s8,8(sp)

40008c: 27bd0010 addiu sp,sp,16

400090: 03e00008 jr ra

400094: 00000000 nop

Ejercicios

1. Que significa resolver direcciones?

2. Porque es necesario resolver direcciones en memoria en la etapa de linkeo?

3. Que diferencia hay entre los formatos ’a.out’, ’COFF’ y ’ELF’?

39

Linking and loading

4. Que diferencia hay entre un programa enlazado en forma estatica y un programa dinamica?

5. Investigue el uso de librerıas compartidas (dynamic link) con resolucion en el momento deejecucion. Como se resuelven llamadas a funciones del DLL?

6. Para que sirve un archivo con formato S-record? Que relacion tiene con los formatos ejecuta-bles?

7. Que es la diferencia entre un archivo ’shared object’ y DLL?

8. Inspeccionar el codigo de la rutina ’start’ de un programa muy simple, y determinar que eslo que hace.

40

Chapter 8

Instruction formats

Objetivo

• Describir la interpretacion de una instruccion

Referencia

Patterson and Hennesey (1997), Computer Organization and Design, 2nd Edition, Morgan Kauff-man, Capıtulo 5.1-5.2

El resultado de la compilacion, enlace y carga de un programa es un conjunto de instrucciones enmemoria. La tarea del camino de datos es recibir instrucciones e interpretar o ejecutarlas. Para ellohay un registro llamado el puntero a instrucciones o contador de programa (PC), un conjunto deregistros ya visto en el lenguaje ensamblador, la memoria para instrucciones y datos, multiplexorespara seleccionar el destino de los resultados y una unidad aritmetica y logica. El control del caminode datos se ejerce mediante los multiplexores.

8.1 Carga de instrucciones

Para cargar una instruccion se requiere incrementar el PC en 4 (con un sumador), grabar elresultado en el PC y colocar esta direccion en el bus de la memoria de instrucciones. Notese queeste sumador podrıa ser la misma ALU del microprocesador o podrıa ser un sumador especıficopara el fin de incrementar el PC.

41

Instruction formats

ss

PC Direccion

Instruccion

bits 26−31

Registrosbits 16−20

bits 11−15

0

1

bits 21−25

Control

Reg Destino

ALU4

El grafico indica la distribucion de los diferentes campos de la instruccion. Los bits del campo decontrol se introducen a una unidad donde se determina si el registro de destino de la instruccionviene del campo $rd o del campo $rt. La lınea de control actua sobre un multiplexor cuya salidaes el conjunto de bits de uno de los campos entrantes.

8.2 Ejecucion de instrucciones tipo ’R’

La instruccion tipo ’R’, por ejemplo, ’add $s1,$s2,$s3’, tiene el formato:

opcode $rs $rt $rd shamt fnnbits 6 5 5 5 5 6 bitsposicion 31-26 25-21 20-16 15-11 10-5 5-0registros $s2 $s3 $s1dec 0 18 19 17 0 32hex 0x00 0x12 0x13 0x11 0x00 0x20bin 000000 10010 10011 10001 00000 100000

Para su ejecucion se tienen que:

• selecionar registros de lectura $rs y $rt

• seleccionar registro de grabacion $rd

• seleccionar sumar en la ALU

• pasar los valores en registros $rs y $rt a la ALU

• ejecutar la suma

• habilitar la grabacion en $rd

• presentar el resultado de la suma al registro $rd

42


ss

ALU

ALU Control

3

ceroInstruccion

Read

Read

Registros

Write

datos a grabar

R/W

Las lıneas de control (operacion de la ALU, habilitacion de grabacion de $rd) vienen de la mismaunidad de control indicada en el paso anterior.

8.3 Ejecucion de instrucciones de acceso a memoria

La instruccion de carga de un dato de memoria a un registro, del tipo ’lw $rt, k($rs)’, por ejemplo,’lw $s1,100($s2) tiene el formato:

opcode $rs $rt knbits 6 5 5 16 bitsregistros $s2 $s1dec 35 18 17 100hex 0x23 0x12 0x11 0x34bin 100011 10010 10001 110100

Su ejecucion implica la necesidad de:

• leer un constante (k) de 16 bits

• extender el signo de este constante hasta 32 bits

• seleccionar el registro $rs para lectura

• seleccionar la operacion sumar en la ALU

• sumar el constante con el valor en un registro $rs

• seleccionar la direccion en memoria identificado por la suma

• habilitar la lectura de esta direccion

• habilitar la grabacion del registro $rt

• grabar $rs con el valor en de memoria

43

Instruction formats

ss

ALU

ALU Control

3

cero

Read

Registros

Write

R/W

Instruccion

16 32

Ext.Signo

Direccion

Datos

Memoria deDatos

MemWrite

MemRead

datos leidos

La diferenciacion entre una instruccion de lectura desde memoria y almacenamiento de un registroen memoria es mediante las lıneas de control, MemWrite, MemRead y RegWrite.

8.4 Ejecucion de bifurcaciones

La ejecucion de la bifurcacion requiere calcular la direccion del destino del salto, en base a PC+4,y tambien determinar si se hace o no se hace el salto, comparando los valores en 2 registros. Ladireccion destino del salto se toma de la instruccion misma (bits 0-15) que es extendido con elbit del signo, y posteriormente desplazado en 2 bits porque las bifurcaciones tienen como destinopalabras, no bytes.

ss

Registros

ALU

ALU

Ext.

Signo

RegWrite

cero

<<2

ALU op

PC+4

direccion

de bifurcacion

44

Chapter 9

Single cycle implementation

Objetivo

• Describir la integracion de un camino de datos simple de un solo ciclo

Referencia


9.1 Integracion de instrucciones ’R’ + load / store

ss

45


9.2 Integracion de busqueda de instruccion

ss

PC

Instruction memory

Read address

Instruction

16 32

Registers

Write register

Write data

Read data 1

Read data 2

Read register 1

Read register 2

Sign extend

ALU result

Zero

Data memory

Address

Write data

Read data

M u x

4

Add

M u x

ALU

RegWrite

ALU operation3

MemRead

MemWrite

ALUSrcMemtoReg

9.3 Control de la ALU

OpCode ALUOp Operacion Funcion ALU accion ALU control35 00 lw xxxxxx sumar 01043 00 sw xxxxxx sumar 0104 01 beq xxxxxx restar 1100 10 sumar 100000 sumar 0100 10 restar 100010 restar 1100 10 AND 100100 and 0000 10 OR 100101 or 0010 10 slt 101010 slt 111

Las lıneas de control de la ALU se generan en la unidad de control que utiliza los bits 26-31 (campode funcion) y 0-5 (campo de operacion) de la instruccion.

46


9.4 El camino de datos y control

ss

PC

Instruction memory

Read address

Instruction [31–0]

Instruction [20 16]

Instruction [25 21]

Add

Instruction [5 0]

MemtoReg

ALUOp

MemWrite

RegWrite

MemRead

Branch

RegDst

ALUSrc

Instruction [31 26]

4

16 32Instruction [15 0]

0

0M u x

0

1

Control

AddALU

result

M u x

0

1

RegistersWrite register

Write data

Read data 1

Read data 2

Read register 1

Read register 2

Sign extend

M u x

1

ALU result

Zero

PCSrc

Data memory

Write data

Read data

M u x

1

Instruction [15 11]

ALU control

Shift left 2

ALU

Address

Senal Deshabilitado HabilitadoRegDst Nro registro destino viene de

campo $rt (bits 16-20)Nro registro destino viene decampo $rd (bits 11-15)

RegWrite - Registro seleccionado por en-trada ’WriteRegister’ se graba

ALUSrc Operando nro 2 de ALU viene deregistro

Operando nro 2 de ALU viene deinstruccion

PCSrc PC = PC + 4 PC = PC + 4 + branch offsetMemRead - Memoria de datos se leenMemWrite - Memoria de datos se grabanMemtoReg Datos a grabar vienen de ALU Datos a grabar en registro viene

de memoria

47


48

Chapter 10

Multicyle implementation

Objetivo

• Describir la construccion de un camino de datos de multiples ciclos por instruccion

Referencia


10.1 Ineficiencia del ciclo unico

El camino de datos simple de un solo ciclo es ineficiente. Cada instruccion se ejecuta en un ciclo.La duracion de un ciclo es uniforme por lo que tiene que equipararse a la instruccion mas larga.Suponiendo que el acceso a memoria tarde 2ns, ALU’s 2ns y acceso a registros 1ns, se puedecalcular la ineficiencia al requerir que cada instruccion se ejecuta en un ciclo.Instruccion mem. inst. reg. rd ALU mem. datos reg. wr TotalALU 2 1 2 0 1 6nslw 2 1 2 2 1 8nssw 2 1 2 2 0 7nsbr 2 1 2 0 0 5nsjmp 2 0 0 0 0 2ns

Si el conjunto de instrucciones incluyera calculos con punto flotante que son mas largas (porejemplo, 5 veces mas) la ineficiencia de una implementacion de ciclo unico serıa mucha mayor.Esta ineficiencia ha dado lugar a una manera de ejecutar las instrucciones en multiples ciclos.Esto no significa que la ejecucion es mas lenta, pero mas bien que los ciclos son mucho mas cortos.Explicitamente, los ciclos pueden durar la quinta parte de un ciclo simple. Algunas de las sentenciasvan a ejecutarse en menos que cinco ciclos, y ası se gana eficiencia general.

49


10.2 Implementacion multiciclo

El concepto de una implementacion multiciclo es dividir el camino de datos en pasos correspon-dientes a a las operaciones fundamentales para la interpretacion de la instruccion. Para ello esnecesario modificar el camino de datos.

• Una sola memoria se utiliza para instrucciones y datos

• Hay una sola ALU para las sumas y el calculo de direccion para el PC

• Se agregan registros despues de las etapas intermedias para contener el resultado de la etapa.Hay 5 registros nuevos:

1. Para contener la instruccion a ejecutar (IR).

2. Para contener un dato de memoria (MDR)

3. Entre los registros y la primera entrada de la ALU (A)

4. Entre los registros y la segunda entrada de la ALU (B)

5. A la salida de la ALU (ALUOut)

El IR requiere mantener su contenido durante varios ciclos de reloj por lo que requiere una senalque habilita grabacion en un ciclo en particular.

ss

Shift left 2

PC

M u x

0

1

RegistersWrite register

Write data

Read data 1

Read data 2

Read register 1

Read register 2


M u x

0

1

M u x

0

1

4


Sign extend

3216




Instruction register

ALU control

ALU result

ALU

Zero

Memory data

register

A

B

IorD

MemRead

MemWrite

MemtoReg

PCWriteCond

PCWrite

IRWrite

ALUOp

ALUSrcB

ALUSrcA

RegDst

PCSource

RegWrite

Control

Outputs

Op [5–0]

Instruction [31-26]

Instruction [5–0]

M u x

0

2

Jump address [31-0]Instruction [25–0] 26 28

Shift left 2

PC [31-28]

1

1 M u x

0

3

2

M u x

0

1ALUOut

Memory

MemData

Write data

Address

El control del camino de multiples ciclos tiene que modificarse. Se agrega un multiplexor parala primera entrada de la ALU para seleccionar entre el registro A o el PC. El multiplexor de lasegunda entrada a la ALU se extiende a 4 posibilidades:

1. registro B

2. el constante 4 (para incrementar el PC)

3. el constante de instrucciones de acceso a memoria (extension de signo)

4. el constante de bifurcaciones (extension de signo y desplazamiento por 2)

50


Las instrucciones J no pasan por la ALU. Se requieren nuevas senales para seleccionar el ciclos dereloj para grabacion del PC, memoria, IR y los registros. Los multiplexores necesitan otras senalesde control, y el PC requiere control sobre si se graba con el constante de una instruccion J, elregistro a la salida de la ALU (ALUOut) o la suma PC + 4. El PC es grabado con el resultadode la suma condicionalmente en el caso de una bifurcacion e incondicionalmente en el caso de lasuma + 4 y de una instruccion J.

10.3 Etapas de ejecucion de una instruccion

Las primeras dos etapas de la interpretacion de una instruccion son iguales para todo tipo deinstruccion. En estas etapas todavıa no se sabe que tipo de instruccion se esta interpretando. Enla tercera, cuarta y quinta etapa la operacion depende del tipo de instruccion.

1. Busqueda de instruccion

• IR = Memory[PC]

• PC = PC + 4

2. Decodificacion de la instruccion

• A = Reg[IR[25-21]]

• B = Reg[IR[20-16]]

• ALUOut = PC + (sign-extend(IR[15-0]) << 2)

3. Ejecucion, calculo de direccion, bifurcacon

• I tipo: ALUOut = A + sign-extend(IR[15-0])

• R tipo: ALUOut = A op B

• Branch: if (A == B) PC = ALUOut

• Jump: PC = PC[31-28] —— (IR[25-0] << 2 )

4. Acceso a memoria o finalizacion de R,I instrucciones

• Mem Ref: MDR = Memory[ALUOut]

• Mem Ref: Memory[ALUOut] = B

• R tipo: Reg[IR[15-11]] = ALUOut

• I tipo: Reg[IR[15-11]] = ALUOut

5. Finalizacion de lectura de memoria

• REg[IR[20-16]] = MDR

51


10.4 Senales de control multiciclo

Senal Deshabilitada HabilitadaRegDst Registro de destino viene

de $rtRegistro de destino viene de $rd

RegWrite - Habilita grabacion de registro con datosALUSrcA ALU operando A viene de

PCALU operando A viene de A

MemRead - Memoria[direccion]->- Memory dataoutput

MemWrite - grabar Memoria[direccion]MemtoReg Memoria data viene de

ALUOutMemoria data viene de MDR

IorD PC ->- direccion paramemoria

ALUOut -> direccion para memoria

IRWrite - memoria ->- IRPCWrite - PC grabado desde origen definido por

PCSourcePCWriteCond - PC grabado si ’zero’ tambien habilitado

Senal valor EfectoALUOp 00 sumarALUOp 01 restarALUOp 10 operacion determinado por campo ’fn’ALUSrcB 00 entrada B a ALU desde BALUSrcB 01 entrada B a ALU es 4ALUSrcB 10 entrada B a ALU IR[15-0] sign-extendedALUSrcB 11 entrada B a ALU IR[15-0] sign-extended << 2PCSource 00 Salida ALU ( PC+4 ) ->- PCPCSource 01 ALUOut (destino bifurcacion) ->- PCPCSource 10 (IR[25-0] << 2 +PC+4[31-28]) ->- PC

Ejercicios

1. Decodifica la instruccion bnet0, t1, F IN , y realiza el seguimiento de los estados de A, B, PC,IR y ALUout durante su ejecucion.

2. Decodifica la instruccion addt2, t0, t1 y realiza el seguimiento de los estados de A, B, PC, IRy ALUout durante su ejecucion.

3. Decodifica la instruccion swt0,−4(sp) y realiza el seguimiento de los estados de A, B, PC,IR y ALUout durante su ejecucion.

4. Dibujar los circuitos necesarios para implementar la instruccion jrreg.

52

Chapter 11

Pipelining

Objetivo

• Introducir el concepto de segmentacion (pipelining) en el camino de datos

Referencia

Patterson and Hennesey (1997), Computer Organization and Design, 2nd Edition, Morgan Kauff-man, Capıtulo 6.1, 6.2

11.1 Segmentacion

Microprocesadores modernos utilizan segmentacion. En la lınea Intel, el 80486 fue el primer mi-croprocesador que usaba segmentacion; los procesadores MIPS siempre usaron segmentacion. Seg-mentacion significa ejecutar multiples instrucciones simultaneamente dentro del camino de datos.

Le ejecucion de una instruccion MIPS tipicamente lleva 5 etapas:

1. Buscar la instruccion de memoria

2. Decodificar la instruccion y leer registros

3. Ejecutar la instruccion o leer una direccion

4. Acceder a un operando en memoria

5. Grabar el resultado en un registro

53

Pipelining

El concepto es iniciar ejecucion de una instruccion cuando la instruccion anterior ha progresadohasta la etapa siguiente. Por ejemplo, cuando se empieza a decodificar una instruccion, ya se estabuscando la instruccion siguiente. La tecnica de segmentacion permite acercarse a ejecutar unainstruccion por ciclo de reloj.

Es necesario modificar el camino de datos y el control para procesar instrucciones con segmentacion.

Instr

ucti

on

mem

ory

Ad

dre

ss

4

32

0

Ad

dA

dd

re

sult

Sh

ift

left

2

Instruction

IF/I

DE

X/M

EM

ME

M/W

B

M

u

x0 1 Ad

d

PC

0

Ad

dre

ss

Wri

te

da

ta

M

u

x1

Re

gis

ters

Rea

d

da

ta 1

Rea

d

da

ta 2

Rea

d

regis

ter

1

Rea

d

regis

ter

2 16

Sig

n

ex

ten

d

Wri

te

regis

ter

Wri

te

da

ta

Rea

d

da

taD

ata

me

mo

ry

1

AL

U

resu

ltM

u

x

AL

U

Zer

o

ID/E

X

Camino de datos incluyendo segmentacion

54


IM Reg DM Reg

IM Reg DM Reg

CC 1 CC 2 CC 3 CC 4 CC 5 CC 6

Time (in clock cycles)

lw $10, 20($1)

Program execution order (in instructions)

sub $11, $2, $3

ALU

ALU

Representacion de camino de datos con 2 instrucciones

55

Pipelining

11.2 Camino de datos

Para disenar un camino de datos segmentado, se utilizan las cinco etapas mencionadas:

1. IF: Instruction fetch

2. ID: Instruction decode / register read

3. EX: Execute / calculate address

4. MEM: Memory access

5. WB: Write back

Entre cada etapa es necesario un registro para almacenar los datos intermedios.

En solo dos instancias puede informacion fluir desde una etapa hacia una etapa anterior, desdeWB -> ID, cuando se graba un dato en un registro, y desde EX -> IF cuando se actualiza el PCcon una direccion calculada. El primero puede generar fallas de datos y el segundo puede generarfallas de control.

56


Instruction

memory

Address

4

32

0

AddAdd

result

Shift

left 2

Inst

ruct

ion

IF/ID EX/MEM MEM/WB

M u x

0

1

Add

PC

0Write data

M u x

1

Registers

Read data 1

Read data 2

Read register 1

Read register 2

16Sign

extend

Write register

Write data

Read data

1

ALU result

M u x

ALU

Zero

ID/EX

Instruction decode

lw $10, 20($1)

Instruction fetch

sub $11, $2, $3

Instruction

memory

Address

4

32

0

AddAdd

result

Shift

left 2

Inst

ruct

ion

IF/ID EX/MEM MEM/WB

M u x

0

1

Add

PC

0Write data

M u x

1

Registers

Read data 1

Read data 2

Read register 1

Read register 2

16Sign

extend

Write register

Write data

Read data

1

ALU result

M u x

ALU

Zero

ID/EX

Instruction fetch

lw $10, 20($1)

Address

Data

memory

Address

Data

memory

Clock 1

Clock 2

Primeros dos ciclos al ejecutar dos instrucciones

57

Pipelining

Instruction

memory

Address

4

0

AddAdd

result

Shift

left 2

Inst

ruct

ion

IF/ID EX/MEM MEM/WB

M u x

0

1

Add

PC

0Write data

M u x

1

Registers

Read data 1

Read data 2

Read register 1

Read register 2

3216Sign

extend

Write register

Write data

Memory

lw $10, 20($1)

Read data

1

ALU result

M u x

ALU

Zero

ID/EX

Execution

sub $11, $2, $3

Instruction

memory

Address

4

0

AddAdd

result

Shift

left 2

Inst

ruct

ion

IF/ID EX/MEM MEM/WB

M u x

0

1

Add

PC

0Write data

M u x

1

Registers

Read data 1

Read data 2

Read register 1

Read register 2

Write register

Write data

Read data

1

ALU result

M u x

ALU

Zero

ID/EX

Execution

lw $10, 20($1)

Instruction decode

sub $11, $2, $3

3216Sign

extend

Address

Data

memory

Data

memory

Address

Clock 3

Clock 4

Siguientes dos ciclos

58


Instruction

memory

Address

4

32

0

AddAdd

result

1

ALU result

Zero

Shift

left 2

Inst

ruct

ion

IF/ID EX/MEMID/EX MEM/WB

Write backM u x

0

1

Add

PC

0Write data

M u x

1

Registers

Read data 1

Read data 2

Read register 1

Read register 2

16Sign

extend

M u x

ALURead data

Write register

Write data

lw $10, 20($1)

Instruction

memory

Address

4

32

0

AddAdd

result

1

ALU result

Zero

Shift

left 2

Inst

ruct

ion

IF/ID EX/MEMID/EX MEM/WB

Write backM u x

0

1

Add

PC

0Write data

M u x

1

Registers

Read data 1

Read data 2

Read register 1

Read register 2

16Sign

extend

M u x

ALURead data

Write register

Write data

sub $11, $2, $3

Memory

sub $11, $2, $3

Address

Data

memory

Address

Data

memory

Clock 6

Clock 5

Ultimos dos ciclos

11.3 Fallas y burbujas en segmentacion

Hay tres tipos de fallas que pueden ocurrir en un camino de datos segmentado:

1. Fallas estructurales

2. Fallas de control

3. Fallas de datos

59

Pipelining

Fallas estructurales

Una falla estructura significa que los recursos estructurales (hardware) en el camino de datos noexisten para soportar segmentacion. Por ejemplo, si no hubiera las ALU’s suficientes para actualizarel PC y sumar registros simultaneamente, o si no hubiera separacion de memorias.

Fallas de control

Un ejemplo de una falla de control es cuando una instruccion es una bifurcacion, por lo que no sesabe de antemano cual es la proxima instruccion a ejecutar. Una solucion es insertar una ’burbuja’,o demora de un ciclo, despues de cada bifuracion.

Otra solucion es suponer cual de las dos ramas va a resultar de la bifurcacion. Si el pronostico escorrecto, no hay demora. Si el pronostico es errado, la demora es varios ciclos.

Instruction fetch

Reg ALUData

accessReg

Time

beq $1, $2, 40

add $4, $5, $6

lw $3, 300($0)

Instruction fetch

Reg ALUData

accessReg

2 ns

Instruction fetch

Reg ALUData

accessReg

2 ns


Instruction fetch

Reg ALUData

accessReg

Time

beq $1, $2, 40

add $4, $5 ,$6

or $7, $8, $9

Instruction fetch

Reg ALUData

accessReg

2 4 6 8 10 12 14

2 4 6 8 10 12 14

Instruction fetch

Reg ALUData

accessReg

2 ns

4 ns

bubble bubble bubble bubble bubble


Falla de control en segmentacion

Fallas de datos

La falla de datos es parecido a la falla por control, pero se refiere a que la ejecucion de unainstruccion depende de un dato en la instruccion anterior:

add $s0, $t0, $t1

60


sub $t2, $s0, $t2

El resultado $s0 es grabado en la quinta etapa, por lo que se tendrıa que insertar tres burbujasantes de ejecutar la segunda instruccion.

Una solucion se sugiere mediante el reconocimiento que el resultado esta disponible antes de suregrabacion en el registro, en este ejemplo $s0. Entonces se puede resolver este problema agregandoun registro interno al camino de datos para almacenar la salida de la ALU.

Otra solucion es modificar la secuencia de ejecucion de codigo insertando una instruccion entre lasdos que acceden al mismo recurso.

11.4 Supersegmentacion

Una tecnica de mejoramiento de la prestacion de un camino de datos es dividir el camino en massegmentos. Ası se estan ejecutando mas instrucciones simultaneamente y la prestacion del caminode datos sera mayor.

Segmentacion superescalar

Segmentacion superescalar significa lectura de multiples instrucciones en cada ciclo de reloj. Pararealizar esto se requieren mas componentes en el camino de datos. El registro de instruccionestiene que ser mas ancho y se requieren multiples ALU’s. Es conveniente secuenciar la ejecucion delas instrucciones para evitar fallas (burbujas) de control o de datos.

L: lw $t0, K($s1) # $t0 = elemento del arreglo

addu $t0, $t0,$s0 #

sw $t0, K($s1) # almacenar resultado de la suma

addi $s1, $s1,-4 # decrementar puntero

bne $s1, $zero,L # volver al inicio del bucle

Supongamos que K es 0x4000, $s1 contiene 16, $s0 contiene 1, y los valores almacenados entre0x4010 (K+$s1) son 1, 2, 3 y 4. Es conviente repasar el codigo, para determinar como funciona, yposteriormente determinar si se podrıa realizarlo en forma superescalar con 2 lıneas en paralelo.

Este ejemplo no permite mucho aumento de prestacion, sin embargo si el bucle es desenrollado, sıpuede mejorar sustancialmente.

Segmentacion dinamica

Segmentacion dinamica es una extension del concepto de secuenciar multiples instrucciones. Paraello se divide el camino de datos en una etapa de busqueda y decodificacion, una etapa de multiples

61

Pipelining

bloques en paralelo de ejecucion y una etapa final de reordenamiento y grabacion de los resultados.Estos se ilustran en el diagrama esquematico:

Commit unit

Instruction fetch and decode unit

…

In-order issue

In-order commit

Load/ Store

Floating point

IntegerInteger …Functional units

Out-of-order execute

Reservation station

Reservation station

Reservation station

Reservation station

62


PC

Instruction memory

4

Registers

Sign extend

M u x

M u x

M u x

Control

ALU

EX

M

WB

M

WB

WB

ID/EX

EX/MEM

MEM/WB

M u x

Data memory

M u x

Hazard detection

unit

Forwarding unit

IF.Flush

IF/ID

M u x

Except PC

40000040

0

M u x

0

M u x

0

M u x

ID.Flush EX.Flush

Cause

Shift left 2

Write data

Read data

Address

Read data

Address Write register

Write data

Read data 1

Read data 2

Read register 1

Read register 2

ALU control

3216

Inst

ruct

ion





Reg

Wri

teALUOp

ALUSrc

RegDst

Mem

Wri

te

MemRead

Mem

toR

eg

Branch

=

63

Pipelining

64

Chapter 12

Cache memory

Objetive

To illustrate solutions to the following questions of memory hierarchy design.

• Where should a memory block be placed.

• How is it found.

• Which block is replaced on a miss

• How are writes handled

• Differentiate write through and write back

Referencia

Patterson and Hennesey (1997), Computer Organization and Design, 2nd Edition, Morgan Kauff-man, Capıtulo 7.1 - 7.3

12.1 Memory hierarchies

Memorias cercanas a la CPU son mas rapidas, mas caras y mas pequenas que las memorias lejanasde la CPU. Though RAM is a screamer compared to disk access, it’s nowhere near as fast as SRAM.Note that disk access is about one million times slower than memory access; that’s milliseconds,not nanoseconds.

65

Cache memory

access time cost (USD ’97)SRAM 5-25ns $100-250DRAM 60-120ns $5-10Disk 10-20ms $0.1-0.2

The advantages of memory hierarchies is that one can take advantage of two characteristics of dataaccess:

• Localizacion temporal: that which was recently used will soon again see the light of day.

• Localizacion espacial: nearer is dearer vs. out of sight, out of mind.

The idea is that when you want to have data in the cache before you use it, so that the access willbe rapid. If you find the data in the cache, it’s called a hit, otherwise it’s a miss. The parameterusually used is the hit rate, the proportion of hits with respect to the total number of data accesses.

Is this important to the programmer? This example from the text (page 617) is a good one:

for (i=0; i != 500; ++i)

for (j=0; j != 500; ++j)

for (k=0; k != 500; ++k)

x[i][j] = x[i][j] + y[i][k] * z[k][j];

On a Silicon Graphics Challenge L with a MIPS R4000, 1MB secondary cache, the execution timeis 77.2 seconds. Inverting the order of the loops to k,j,i reduces the execution time to 44.2 seconds.But, on a Linux Pentium, the differences are minimized. It’s a worthwhile exercise to explain why.

12.2 Cache Memory

Cache memory is that part of the memory hierarchy that falls between the processor and mainmemory (RAM). In order to use a cache memory, you need to know if the data you want is in thecache, and if it is in the cache, where is it. The simplest scheme is to use direct mapping. In theillustration (Fig. 12.1) a cache consisting of 8 elements is shown. This cache is for memory with32 elements.

The addressing for direct mapping is to use the equation:

(Cache address) = (RAM address) % (cache size) (12.1)

In our illustration, the cache size is 8, and the RAM addresses go from 0 up to 31. Since the cachesize is a power of 2, the cache address is simply the lower 3 bits of the RAM address. Recall that inthis cache / memory scheme, each cache element will hold one of four possible memory elements.So, we need to know which of the memory elements is occupying the cache at the moment. Thisis done by saving a tag field along with the cache element. The tag field is loaded with the upper

66


00001 00101 01001 01101 10001 10101 11001 11101

000

Cache

Memory

001

010

011

100

101

110

111

Figure 12.1: Direct map cache

bits of the memory element currently stored in the cache. In Figure 12.2, the fields of a directmapped cache are shown, along with a RAM address. In this example, the RAM elements are 32bits long, and the cache has 1024 (= 210) elements. So following Equation 12.1, the cache addresswill be 10 bits from the RAM address (the address is offset by a couple of bits to access only 4 bytewords). The tag field will be the 20 remaining upper bits, and there is a flag to indicate whetherthe data is valid or not. On startup, the cache is empty, and so the data is not valid. This is quitedifferent from valid data that is just zeros.

To write to memory, one must make sure that the cache and memory are consistent, or that theinconsistency can be handled. The simplest approach to eliminating cache inconsistency is to usethe scheme termed write through. This means that when the cache is update (altered by a write),main memory is always updated. This will ensure consistency, but it clearly eliminates the valueof a cache on writes. A write buffer can store data while it is being written to memory. Theprocessor is freed after writing to cache and the write buffer, and while the processor continues onits merry way, the write buffer is dumped to RAM.

A write back scheme is faster that write through, however it is more complicated, and fragile. Thedata is written to the cache, but not to main memory. When the updated (and inconsistent) cacheelement is about to be replaced, then the main memory is updated and brought into consistency.

Access to data and instructions frequently has spatial proximity that can be used to advantage byincreasing the number of elements in each cache block. The idea is to read from several adjacentmemory elements simultaneously since if adjacent elements are likely to be needed soon after thefirst element.

67

Cache memoryAddress (showing bit positions)

20 10

Byte offset

Valid Tag DataIndex

0

1

2

1021

1022

1023

Tag

Index

Hit Data

20 32

31 30 13 12 11 2 1 0

Figure 12.2: Cache addressing

1

2Tag

Data

Block # 0 1 2 3 4 5 6 7

Search

Direct mapped

1

2Tag

Data

Set # 0 1 2 3

Search

Set associative

1

2Tag

Data

Search

Fully associative

Figure 12.3: Alternative caching schemes

12.3 Associative caches

The caching schemes mentioned up to this point, have all been direct mapping. Even with multipleelements in each block, a memory element has only one location in the cache where it can be stored.This leads to a situation where the cache might be half empty, but memory requests will still causemisses. For example, in our 8 element cache of Figure 12.1, if we are accessing each 8th address inmemory, the cache will always miss, yet be 87% empty.

Al alternative scheme of cache storage is to permit elements to be stored in more than one positionof the cache. This is somewhat like hashing algorithms, but in this context the terms are set-associative and fully associative. These are illustrated in Figure 12.3.

In a set-associative scheme multiple cache elements are available for each memory address. Tofind whether a memory element is cached or not, the tags for each cache element in the set mustbe searched. Figure 12.3 shows a set-associative scheme with sets of two elements. The fully

68


associative scheme is similar to a linear search; any memory element can be in any cache position.The fully associative scheme minimizes the cache miss ratio, but increases the response time for acache hit.

12.4 Multilevel Caches

The lowest level cache, or L1 cache, is normally fabricated on the same die as the microprocessor.A second level cache, L2, can be implemented off-chip, slower than the L1 memory, but a muchlarger size. With both L1 and L2 caches, the design parameters for both can be modified. Theprimary, L1, cache will be designed to minimize the hit time and thereby create a shorter executiontime for each instruction. The secondary, L2, cache will be designed to reduce the miss rate andthereby avoid the penalty of the long delay in main memory access. The L1 cache in a multilevelsystem will have smaller blocks than in a single cache system, and so reduce the time to retrievean element from the cache. The L2 cache in the multilevel cache system will have a larger blocksize, more elements per block, and so reduce the miss rate, the accesses to main memory.

Exercises

1. Describe the cache contents after each of the following memory requests, assuming the cachetobe initially empty. The cache is directly mapped with 8 blocks.RAM address h / m cache block

0x160x1a0x160x160x100x030x100x120x060x04

2. What would the sequence be if the cache in problem 1 were two way associative?

3. Explain how the large block size of the L2 cache reduces the miss rate of the memory hierarchy,as opposed to a smaller block size cache.

4. Explain how the smaller block size of an L1 cache reduces the hit rate of the memory hierarchy.

69

Cache memory

70

Chapter 13

Memoria Virtual

Objetivo

• Describir la integracion de memoria virtual a la jerarquıa de memorias del computador

Referencia

Patterson and Hennesey (1997), Computer Organization and Design, 2nd Edition, Morgan Kauff-man, Capıtulo 7.4 - 7.5http://en.wikipedia.org

13.1 Physical and virtual addresses

Virtual memory is a fundamental support for multitasking, multiuser, multiprocessor and parallelsystems. This virtual memory provides each process with its own address space so that the processwill be able to operate as though it owns the machine, though in fact the underlying hardware andoperating system are relocating the addresses that the process sees to other addresses are quitedifferent from the addresses that the linker assigns.

Another important facet of virtual memory is that a process may use more memory than themachine physical possesses; the additional memory is mapped to disk. Unders Windows, thisspace on disk is a file, called ’pagefile.sys’ or WIN386.SWP. Under Linux, a partition is created forswapping.

The concept of virtual memory is very similar to cache memory, but instead of being between theprocessor and DRAM, virtual memory lies between DRAM and disk. And because virtual memoryarose independently of cache memory, the terminology is slightly different. Virtual memory systemswill refer to pages (instead of blocks), page faults and page swapping. The combination of virtual

71

Memoria Virtual

memory and cache memory is called the memory hierarchy, and is a fundamental component ofhigh performance computers. Low performance computers (optimized for low energy consumption,or low price) will not use memory hierarchy control, which limits their possibility of runningmultitasking operating systems like Unix.

If a memory request can not be served from the caches, the memory management unit (MMU)hardware translates the address from that requested by the process to the physical address inDRAM. If the requested physical address is not present in DRAM, the page fault is generatedand the page must be brought into memory from disk. This is the page fault, and you can verywell imagine how slow it is compared with direct memory access. The block must be loaded intomemory, usually pushing some other page back out to disk. In the same fashion as in cachemanagement, virtual memory can be written out to physical memory using either write back orwrite through strategies. Assuming write back is used, information on your disk will be corruptedif the machine is suddenly de-energized without synchronizing disk and memory.

The MMU hardware is responsible for this translation, protecting memory that a process shouldaccess from corruption and control of the cache. Within the MMU the virtual to physical addresstranslation is performed by an associative cache termed the table lookaside buffer (TLB). TheTLB will also include information indicating when the page was last used to permit selection ofwhich page to swap out to disk, what type of process (user or supervisor) is using the page andwhether the page has been written and is consequently dirty. The presence of an MMU in a CPUis a requirement for a multitasking operating system such as Linux. For processors without anMMU, such as the M-Core, the DragonBall, the ColdFire, etc. an alternative version, µCLinux(http://www.uclinux.org) is available.

A virtual address is divided into two parts as illustrated in Figure 13.2, the number of the (virtual)page, and the offset within the page. The offset will be exactly the same for both virtual andphysical addresses, but the page number will be diferent. Virtual memory can have higher pagenumbers than physical memory. Since disk access is so much slower than DRAM access, theprincipal design objective for virtual memory systems is to prevent page faults. Consequently afully associative structure is preferable to direct mapping.

Physical addresses

Disk addresses

Virtual addresses

Address translation

Figure 13.1: Overview of virtual memory

72


Using a fully associative scheme for page assignment, a virtual page can end up at any page inphysical memory. The mapping between the virtual page and the physical page is contained in thepage table, Figure 13.3. A valid bit indicates whether the virtual page is in physical memory, or ifthe process must retrieve the page from disk. Note that in Figure 13.3, the virtual memory pagenumber is represented with 20 bits whereas the physical memory page number is only 18 bits.

3 2 1 011 10 9 815 14 13 1231 30 29 28 27

Page offsetVirtual page number

Virtual address

3 2 1 011 10 9 815 14 13 1229 28 27

Page offsetPhysical page number

Physical address

Translation

Figure 13.2: Address translation

Page offsetVirtual page number

Virtual address

Page offsetPhysical page number

Physical address

Physical page numberValid

If 0 then page is not present in memory

Page table register

Page table

20 12

18

31 30 29 28 27 15 14 13 12 11 10 9 8 3 2 1 0

29 28 27 15 14 13 12 11 10 9 8 3 2 1 0

Figure 13.3: Page table

73

Memoria Virtual

Another detail is that a register in the CPU, the page table register contains the address of thepage table, so that finding the page table in DRAM can be fast. Since each process has its ownpage table, the operating system will simply change the page table register when the OS needs toswitch from one process to another. Process switching requires changing:

1. Page table

2. Program counter

3. CPU registers

On a MIPS for example, this means a minimum of 34 writes to memory each time a process isswitched.

Exercises

1. On a mono-processor computer, which should be faster, a single threaded set of operationsor the same set of operations divided into multiple threads?

2. In what circumstances could the inverse be true?

3. How would you implement task switching without a MMU?

4. Write a program that fits in memory, and one that doesn’t. Attempt to provoke disk thrashing(constant switching processes out to disk).

74

Chapter 14

Cell Broadband Engine

The Cell BE has created, or is a result of, renewed interest in multiprocessadores, as a means ofmaintaining the pace of improving processor performance. A great deal of information is availableon the web regarding the programming and architecture of the Cell BE, especially since it runsLinux. One site that looks good for the architecture is:

http://www.blachford.info/computer/Cell/Cell1 v2.html

Both IBM and MIT are also very good soures for info on the Cell BE.

14.1 Architecture

The architecture of the Cell BE is unusual, in that it includes different types of processors in onechip which is why it is called a heterogeneous processor. A 64 bit PowerPC is used as an overallsupervisor and is termed a ’Power Processing Element’ in the jargon of the Cell BE. The PPE hasan internal 32Kbyte L1 cache and an external 512Kbyte L2 cache.

The PPE is connected to eight vector processors on the same chip via an internal bus, the ’ElementInterconnect Bus’ (EIB). A vector processor receives multiple, simultaneous streams of data whichall are operated on by one single instruction (SIMD, Single Instruction, Multiple Data). Forexample, if you must filter an image with a 3x3 kernel, you will probably have nine multiplicationsand nine additions between the kernel and the image. The instructions are the same for eachelement of the filter, but the data is different. This is quite different from scalar processors whichare SISD, Single Instruction, Single Data.

75


76


The vector processors in the Cell BE are known as ’Synergistc Processor Elements’ (SPE’s), andeach can process four streams of data simultaneaously. The SPE’s include a 255Kbyte local datastore, controlled by a ’Memory Flow Controller’ (MFC). The local data store is similar to a localcache, in that it is on-chip, and is a small, fast memory. However, the local store does not rep Thememory access between an SPE and memory uses virtual memory addresses specified in memorytables managed by the PPE.

77


14.2 Programming

To develop applications on the Cell BE, we will use the IBM SDK running under Linux, availablefrom the Barcelona Supercomputing Center. Version 2.1 was released 30 March 2007, for Fedora6. The operating system loads a PPE thread which then creates other threads, both for the PPEand SPE’s. The text portions of an executable file, will be for the PPE and others will be for theSPE. The SPE threads must load their code into the SPE local store and initiate execution at aspecified address.

78

Chapter 15

Atmel AVR

15.1 Architecture

The Atmel AVR’s are eight bit microprocessors with Harvard architecture (separate instructionand data storage) and on-chip flash. Within the data space, which is implemented as SRAM, thefirst 32 memory addresses are treated as the 8-bit working registers, followed by 64 I/O registersand data memory.

79

Atmel AVR

Instruction execution is with a one stage pipeline; while one instruction is being executed, the nextinstruction is being fetched.

15.2 Programming

One nice feature of the AVR family is that the GCC compiler chain is available for the processors.You will install the cross compiler on your desktop PC, develop your program and then load theprogram onto your AVR. The loading step can be done with JTAG devices or ISP connectors.

A good site for the GCC chain on AVR is:

http://users.rcn.com/rneswold/avr

and for using an AVR in a small project:

http://www.linuxfocus.org/English/November2004/article352.shtml

80

Universidad de Talca Facultad de Ingenier´ıa Escuela de ... · macio´n y seleccio´n de...

Documents

Transcript of Universidad de Talca Facultad de Ingenier´ıa Escuela de ... · macio´n y seleccio´n de...