Arquitectura de Computadoras II · Sin una memoria de la que los procesadores leyeran o escribieran...

ANALISTA PROGRAMADOR UNIVERSITARIO Departamento de Economa, Produccin e Innovacin Tecnolgica Universidad Nacional De Jos C. Paz

Arquitectura de

Computadoras II

Profesores:

Lic. Juan Funes

Lic. Walter Salguero

Lic. Fabin Palacios

http://campusvirtual.unpaz.edu.ar

1er. Cuatrimestre 2018

Arquitectura de Computadoras II UNPAZ

1 http://campusvirtual.unpaz.edu.ar Profesores: Juan Funes, Walter Salguero, Fabin Palacios

Tabla de contenido Unidad 1 - MEMORIA -------------------------------------------------------------------------------------------- 4

1 - Jerarqua de Memoria --------------------------------------------------------------------------------------- 4

2. Memoria Cach ------------------------------------------------------------------------------------------------- 6

Poltica de ubicacin ------------------------------------------------------------------------------------------- 12

Correspondencia directa ----------------------------------------------------------------------------------- 13

Correspondencia asociativa------------------------------------------------------------------------------- 17

Correspondencia asociativa de conjuntos---------------------------------------------------------------- 19

Poltica De Sustitucin ----------------------------------------------------------------------------------------- 22

Poltica De Actualizacin-------------------------------------------------------------------------------------- 24

Tamao de la cach -------------------------------------------------------------------------------------------- 25

Cachs compartidas o separadas ------------------------------------------------------------------------ 33

3. Memoria Principal ----------------------------------------------------------------------------------------- 42

Bibliografa; ------------------------------------------------------------------------------------------------------ 52

Unidad 2 Segmentacin del Cauce (Pipeline) -------------------------------------------------- 53

1- Conceptos Bsicos ------------------------------------------------------------------------------------------- 53

2 - Etapas del MIPS64 ------------------------------------------------------------------------------------------ 63

3. Riesgos (Ralentizacin del Cauce) ----------------------------------------------------------------------- 69

Bibliografa; ------------------------------------------------------------------------------------------------------ 86

Unidad 3 Arquitecturas De Computadoras Paralelas --------------------------------------- 87

3.1 - ASPECTOS DEL DISEO DE COMPUTADORAS PARALELAS -------------------------------------- 88

3.1.1 Modelos de comunicacin ----------------------------------------------------------------------------- 91

Multiprocesadores ------------------------------------------------------------------------------------------- 91

Multicomputadoras ----------------------------------------------------------------------------------------- 92

3.1.2 Redes de interconexin -------------------------------------------------------------------------------- 96

Topologa ------------------------------------------------------------------------------------------------------- 98

Conmutacin ------------------------------------------------------------------------------------------------ 102

Algoritmos de enrutamiento ---------------------------------------------------------------------------- 104

3.1.3 Desempeo ---------------------------------------------------------------------------------------------- 106

Mtricas de hardware ------------------------------------------------------------------------------------ 106

Mtricas de software ------------------------------------------------------------------------------------- 107

Cmo lograr un buen desempeo --------------------------------------------------------------------- 109

3.1.4 Software-------------------------------------------------------------------------------------------------- 111

A. Modelos de control --------------------------------------------------------------------------------- 112

B. Granularidad del paralelismo --------------------------------------------------------------------- 113

C. Paradigmas computacionales -------------------------------------------------------------------- 114

D. Mtodos de comunicacin ------------------------------------------------------------------------ 115

E. Primitivas de sincronizacin ---------------------------------------------------------------------- 116



3.1.5 Taxonoma de computadoras paralelas ---------------------------------------------------------- 117

8.2 COMPUTADORAS SIMD --------------------------------------------------------------------------------- 123

8.2.1 Arreglos de procesadores ---------------------------------------------------------------------------- 123

8.2.2 Procesadores vectoriales ---------------------------------------------------------------------------- 124

La supercomputadora vectorial Cray-1 --------------------------------------------------------------- 126

8.3 MULTIPROCESADORES CON MEMORIA COMPARTIDA ----------------------------------------- 128

8.3.1 Semntica de la memoria ---------------------------------------------------------------------------- 128

Consistencia estricta -------------------------------------------------------------------------------------- 129

Consistencia secuencial ---------------------------------------------------------------------------------- 129

Consistencia del procesador ---------------------------------------------------------------------------- 130

Consistencia dbil ------------------------------------------------------------------------------------------ 131

Consistencia de liberacin ------------------------------------------------------------------------------- 132

8.3.2 Arquitecturas SMP basadas en el bus UMA ----------------------------------------------------- 132

Cach espa -------------------------------------------------------------------------------------------------- 133

El protocolo de coherencia de cach MESI ---------------------------------------------------------- 136

8.3.3 Multiprocesadores UMA que usan conmutadores de barras cruzadas ------------------ 138

El Sun Enterprise 10000 ---------------------------------------------------------------------------------- 139

8.3.4 Multiprocesadores UMA que usan redes de conmutacin multietapas ----------------- 140

8.3.5 Multiprocesadores NUMA --------------------------------------------------------------------------- 142

8.3.6 Multiprocesadores NUMA con coherencia de cach ----------------------------------------- 143

El multiprocesador Stanford DASH -------------------------------------------------------------------- 146

El multiprocesador Sequent NUMA-Q ---------------------------------------------------------------- 148

8.3.7 Multiprocesadores COMA --------------------------------------------------------------------------- 152

8.4 MULTICOMPUTADORAS DE TRANSFERENCIA DE MENSAJES ---------------------------------- 154

8.4.1 Procesadores masivamente paralelos (MPP) --------------------------------------------------- 155

El Cray T3E --------------------------------------------------------------------------------------------------- 156

El Intel/Sandia Option Red ------------------------------------------------------------------------------- 158

8.4.2 Cmulos de estaciones de trabajo (COW) ------------------------------------------------------- 159

8.4.3 Planificacin --------------------------------------------------------------------------------------------- 160

Redes de interconexin comerciales ------------------------------------------------------------------ 161

8.4.4 Software de comunicacin para multicomputadoras ----------------------------------------- 164

PVM Mquina Virtual Paralela ---------------------------------------------------------------------- 166

MPIInterfaz de Transferencia de Mensajes ------------------------------------------------------- 167

8.4.5 Memoria compartida en el nivel de aplicaciones ---------------------------------------------- 168

Memoria compartida distribuida ---------------------------------------------------------------------- 168

Linda----------------------------------------------------------------------------------------------------------- 171

Orca ----------------------------------------------------------------------------------------------------------- 173

Globe ---------------------------------------------------------------------------------------------------------- 175

3.2 RESUMEN--------------------------------------------------------------------------------------------------- 175



GUIA DE PREGUNTAS ------------------------------------------------------------------------------------------- 177

Gua de Preguntas Unidad I ------------------------------------------------------------------------------ 178

Gua de Preguntas Unidad II------------------------------------------------------------------------------ 179

Gua de Preguntas Unidad III ----------------------------------------------------------------------------- 180

Cronograma y Horarios ----------------------------------------------------------------------------------------- 182

Horario de cursada ---------------------------------------------------------------------------------------- 182

Cronogramas Sujetos a modificaciones -------------------------------------------------------------- 182

Calendario Acadmico 2018 ----------------------------------------------------------------------------- 183

Anexo ---------------------------------------------------------------------------------------------------------------- 184

Instrucciones MIPS64 ------------------------------------------------------------------------------------- 185

SISD VS SIMD ------------------------------------------------------------------------------------------------ 186

Supermicro 4028GR-TR 4U 8-Way GPU SuperServer Review ----------------------------------- 189

El rnking de las supercomputadoras ----------------------------------------------------------------- 192

Supercomputadora con procesadores chinos rebasa a la competencia --------------------- 193

Sequoia IBM BlueGene/Q -------------------------------------------------------------------------------- 195

Anlisis a fondo: Arquitectura GPU NVIDIA Pascal Diseada para la velocidad ---------- 207

El paralelismo ----------------------------------------------------------------------------------------------- 230



Unidad 1 - MEMORIA

1 - Jerarqua de Memoria

La informacin con la que opera un procesador se encuentra en una memoria

interna muy reducida conocida como los registros. Esta pequea memoria no puede

albergar toda la informacin requerida por un programa, por lo que se requiere una

memoria externa adicional. Esta memoria externa es de mucha ms capacidad,

aunque tambin mucho ms lenta de acceso.

En este captulo nos vamos a centrar en esta memoria externa que, como

veremos, se estructura en una jerarqua de distintas tecnologas de memoria,

consiguiendo as una muy buena relacin de capacidad, tiempo de acceso y precio.

Nos centraremos, sobre todo, en la memoria ms cercana y rpida, la memoria

cach. Luego se ver una breve presentacin a los tipos y tecnologas de la memoria

principal y, por ltimo, haremos una pequea introduccin a la memoria virtual.

La memoria es la parte del ordenador en la que se guardan o almacenan los

programas (las instrucciones y los datos). Sin una memoria de la que los procesadores

leyeran o escribieran la informacin, no habra ordenadores digitales de programa

almacenado (como son todos los actuales desde el EDVAC en 1945).

Por una parte tenemos que la velocidad de ejecucin de los programas es

muy dependiente de la velocidad a la que se pueden transferir los datos entre la

CPU y la memoria. Por otra parte, tambin es importante disponer de una gran

cantidad de memoria, para facilitar la ejecucin de programas que son grandes o que

trabajan con una gran cantidad de datos.

Por esto, idealmente, la memoria debera ser rpida, grande y barata. Como

cabra esperar, hay un compromiso entre estas tres caractersticas de la memoria que

mantienen las siguientes relaciones:

A menor tiempo de acceso mayor coste por bit.

A mayor capacidad menor coste por bit.

A mayor capacidad mayor tiempo de acceso

Al diseador de la arquitectura de un ordenar le gustara disponer de una

tecnologa de memoria que le proporcionara una gran capacidad, tanto porque le



ofrece una gran cantidad de memoria, como porque el coste por bit es pequeo. Sin

embargo, para conseguir buen rendimiento y velocidad se necesitan memorias de

rpido acceso, que son de poca capacidad y ms caras.

La pirmide del grfico superior, est construida por diversos tipos de memoria,

de tal manera que a medida que se va de arriba hacia abajo, sucede lo siguiente:

Disminuye el coste por bit Aumenta la capacidad Aumenta el tiempo de acceso Disminuye la frecuencia de acceso a la memoria desde la CPU

La clave de la solucin est en este ltimo punto: la decreciente frecuencia de

acceso. Esto simplemente quiere decir que no se accede a todos los datos con la

misma frecuencia; obviamente se accede ms a los datos del programa en ejecucin

que a los de uno que no se ejecuta desde hace un ao; y de igual manera, en un

momento dado se accede ms a los datos de una expresin que se est evaluando en

ese preciso instante que a otros datos del programa.

En lugar de decidirnos por un nico tipo o tecnologa de memoria, lo que hay

que hacer es construir una estructura con una jerarqua de memoria en la que haya

diversas tecnologas, de tal manera que los pocos datos con los que se est

ejecutando la instruccin en curso estn en los registros de la CPU; los datos de las

ltimas instrucciones, en la memoria cach; el resto de los datos del programa en

ejecucin estarn repartidos entre memoria principal y secundaria de rpido acceso

(discos magnticos); los programas o datos que no se ejecutan asiduamente se

guardan en memoria secundaria rpida y en memorias secundarias masivas de mayor

tiempo de acceso, como la cinta magntica y el disco ptico.

La CPU y el sistema operativo se encargarn de ir llevando y trayendo los

datos de las memorias lentas a las rpidas y viceversa, a medida que se vayan

referenciando los distintos datos o programas.



En la figura de arriba se pueden ver los rdenes de magnitud de capacidad y

tiempo de acceso de los componentes que ocupan los distintos niveles de la jerarqua

de memoria.

El procesador dispone de unos registros cuyo tamao puede ir desde unos

pocos octetos a unos kilobytes de memoria; su tiempo de acceso est alrededor de

250ps.

La memoria cach, actualmente, tiene una capacidad que puede ir de unos 64

KB hasta ms de un megabyte. En cuanto a su tiempo de acceso, est alrededor de

1ns.

La capacidad de la memoria principal es del orden de gigabytes, mientras que

su tiempo de acceso est por debajo de los 100ns.

Por ltimo, los dispositivos de almacenamiento de memoria masiva

(dispositivos de entrada/salida), ya ofrecen una capacidad de varios terabytes, aunque

su tiempo de acceso oscila entre 2 y 20 ms. Como se puede apreciar, segn se

desciende en la jerarqua de memoria hacia los dispositivos de almacenamiento

masivo, la capacidad va aumentando en un factor de 1000, pero el tiempo de acceso

tambin lo hace, segn un factor de 100.

Los discos de estado slido (SSD) tienen un tiempo de acceso de alrededor de

una dcima de segundo, aunque, de momento, son de menor capacidad que los

convencionales de platos giratorios, pues los discos comunes SSD no pasan de 480

GB.

2. Memoria Cach

Vamos a comenzar por el primer nivel de la memoria externa al procesador, la

memoria cach, situada entre la CPU y la memoria principal.

Veremos cmo una memoria tan pequea (en comparacin con la memoria

principal) puede ser tan til, y las maneras en que se puede organizar para

aprovecharla de la mejor manera posible.

La cach es una pequea memoria situada entre el procesador y la memoria

principal, que, aunque muy rpida, solamente dispone de unos cuantos kilobytes de

capacidad.



La efectividad del mecanismo de la memoria cach se basa en una propiedad

de los programas denominada Localidad de referencia y que comentamos a

continuacin.

El Principio de Localidad de Referencia dice que los accesos a memoria que

realiza la CPU no estn uniformemente distribuidos por todo el espacio de direcciones,

sino que, temporalmente, se concentran en reas de la memoria.

Lo que establece este principio se debe a que el contenido de cada programa

no est esparcido por toda la memoria, sino que sus instrucciones y datos estn

contenidos en una o varias secciones de memoria contigua, por lo que los accesos a

la memoria se concentran en las reas donde estn las instrucciones o los datos del

programa en ejecucin.

El anlisis de los programas muestra que la mayora del tiempo de ejecucin se

dedica a rutinas en las que una serie de instrucciones se ejecutan repetidamente.

Estas instrucciones pueden estar formando parte de un bucle, bucles anidados, o unos

cuantos procedimientos a los que se llama iterativamente. Por esto, las referencias a

memoria en una porcin de tiempo dada, se concentran, concretamente, no en todo el

programa que se est ejecutando, sino, ms especficamente, en el fragmento del

bucle que en ese momento se est ejecutando.

Segn esto, si el segmento activo de un programa se puede ubicar en una

memoria rpida, aunque pequea, el tiempo total de ejecucin puede verse

drsticamente reducido.



El principio de localidad se manifiesta en dos aspectos: temporal y espacial.

La localidad de referencia temporal se debe a la naturaleza repetitiva de los

programas o de porciones de los programas, y significa que, tal y como hemos visto en

la pgina anterior, una instruccin que se acaba de ejecutar recientemente es muy

probable que se vuelva a ejecutar en un futuro muy prximo. Ahora, la secuencia

detallada de la ejecucin de las instrucciones no es significativa, lo que realmente nos

importa es que muchas instrucciones localizadas en reas concretas del programa,

debido a los bucles que las encierran, se ejecutan repetidamente durante un periodo

de tiempo, mientras que al resto del programa o del resto de la memoria solo se

accede muy de vez en cuando.

El aspecto espacial quiere decir que las instrucciones que se encuentran en la

proximidad de una instruccin recientemente ejecutada (en cuanto a sus direcciones

en memoria) tambin es muy probable que se ejecuten muy pronto. A los datos u

operandos de un programa les sucede lo mismo, no estn dispersos por toda la

memoria, sino que estn agrupados en una zona de la misma, y ocupando direcciones

contiguas.

Dado que el tiempo de acceso a la memoria principal es muy costoso y

teniendo en cuenta lo que nos dice la localidad espacial, parece conveniente que

cuando se accede a ella para obtener un byte o una palabra necesitada por la CPU, en

lugar de transferir solamente el dato solicitado por la CPU, se aproveche el viaje

para transferir, no solamente ese byte o palabra, sino un bloque contiguo de

informacin que contenga dicho byte y unos pocos ms que estn en las direcciones

cercanas. As, cuando se utiliza una memoria cach, la unidad de transferencia entre

sta y la memoria principal es el bloque.

El tamao de un bloque suele ser el ancho del bus de datos o un mltiplo de l,

es decir, 2, 4, 8, bytes.



Conceptualmente el funcionamiento de una memoria cach es muy simple. La

circuitera de control de la memoria est diseada para aprovechar la localidad de

referencia. De acuerdo con el aspecto temporal de la localidad de referencia, siempre

que un dato se necesita por primera vez, se debe traer a la memoria cach, en la que

permanece, de tal forma que cuando se le vuelva a necesitar, se podr obtener muy

rpidamente.

Por su parte, la localidad espacial aconseja que en lugar de traer a la cach

solamente el dato referenciado, se traiga el grupo de datos que reside en direcciones

adyacentes a dicho dato. En el contexto de las cachs, se emplea el trmino bloque

para referirse a un conjunto de datos con direcciones contiguas que se utiliza como

unidad de transferencia entre la memoria principal y la cach. El espacio que tiene una

cach para albergar un bloque de memoria principal se denomina lnea.

Como se muestra en la figura, cuando se recibe una peticin de lectura de la

CPU, el contenido del bloque completo de memoria principal que contiene la direccin

especificada se transfiere a la cach. Posteriormente, cuando el programa referencia

cualquiera de las direcciones del bloque, el contenido correspondiente se lee

directamente de la cach (solamente la palabra o parte de la palabra referenciada, no

el bloque completo).



Cuando la CPU intenta leer una palabra de memoria principal, se le presenta la

direccin a la memoria cach y sta comprueba si tiene el dato correspondiente a esa

direccin. Si es as, entrega el dato; si no, se produce una falta de cach, con lo que

hay que acudir a la memoria principal para leer un bloque de varias palabras

adyacentes en memoria. Como ya hemos comentado, el hecho de leer un bloque, y no

solamente la palabra concreta referenciada, se debe al principio de localidad de

referencia espacial, pues cuando en la CPU se genera una referencia a una palabra

concreta, es muy fcil que en las prximas lecturas se haga referencia a otras

palabras cercanas a esa palabra

.

Como se muestra en la figura, cuando se recibe una peticin de lectura de la

CPU, el contenido del bloque completo de memoria principal que contiene la direccin

especificada se transfiere a la cach. Posteriormente, cuando el programa referencia

cualquiera de las direcciones del bloque, el contenido correspondiente se lee

directamente de la cach.

Normalmente la memoria cach puede almacenar un nmero de bloques de

memoria que es muy pequeo comparado con el nmero de bloques de la memoria

principal. La correspondencia entre los bloques de la memoria principal y los que se

encuentran en la cach se denomina funcin de correspondencia. La funcin de

correspondencia a utilizar se establece mediante la poltica de ubicacin. Cuando la

cach est llena, y se referencia una direccin cuyo bloque no est en la cach, el

hardware de la cach debe decidir qu bloque deber ser expulsado para dejar

espacio al bloque que se acaba de referenciar. El conjunto de reglas que se utilizan

para tomar esta decisin se denominan algoritmos o polticas de sustitucin.

Obsrvese que la CPU no necesita conocer explcitamente la existencia de la

cach, sino que genera una peticin de lectura o escritura utilizando direcciones de

memoria principal, y la circuitera de la cach determina si la palabra solicitada est o

no est en ese momento en la cach. Si est (se dice que se ha producido un acierto

de cach), la operacin de lectura o escritura se realiza sobre la direccin

correspondiente en la cach, y si la operacin es de lectura, la memoria principal no se

ve implicada en la ejecucin. Si la operacin es una escritura, la palabra afectada en la

memoria cach deber actualizarse, en algn momento, en la memoria principal, para

que el contenido de un bloque en la cach sea idntico al de su correspondiente en

memoria principal. En estos casos, la actualizacin en memoria principal de los

bloques modificados en la cach se realiza segn una poltica de escritura o de

actualizacin.



Cuando el dato referenciado por una lectura de la CPU no est en la cach, se

produce una falta o fallo de cach. En este caso, el bloque que contiene la palabra

referenciada se copia de la memoria principal a la cach, y a continuacin, la palabra

solicitada se enva a la CPU. Otra opcin consiste en enviarle la palabra directamente

de la memoria principal a la CPU y al mismo tiempo cargarla en la cach. Esta ltima

tcnica, denominada carga directa (load through), aunque reduce el tiempo de

espera de la CPU, requiere un hardware ms complejo.

Ms adelante, al comentar las polticas de escritura, veremos las opciones a

tomar cuando se produce una falta de cach en una operacin de escritura.

En la operacin de la cach se nos plantean, por tanto, estas tres preguntas:

P1: Dnde situar un bloque en la cach? (Poltica de ubicacin).

P2: Qu bloque reemplazar ante una cach llena? (Poltica de sustitucin).

P3: Qu hacer ante una operacin de escritura? (Poltica de actualizacin).

Sabemos que la memoria principal est formada por un mximo de 2n celdas

direccionables, cada una con una nica direccin de n bits. Desde el punto de vista de

la cach, esta misma memoria principal se considera formada por M bloques de K

celdas cada uno; es decir, por 2n/K bloques. La cach por su parte, est formada por C

entradas de K celdas cada una, tal que el nmero de entradas de la cach es mucho

menor que el nmero de bloques de la memoria principal. Cuando se lee una celda de

un bloque de memoria, ese bloque se transfiere a la cach, por lo que en un momento

dado, la cach est cargada con un subconjunto de los bloques de memoria.

Ya que hay ms bloques de memoria que entradas o lneas en la cach, cada

entrada de la cach no puede estar permanentemente dedicada a un bloque concreto

de la memoria principal. Por esto, cada entrada de la cach tiene una etiqueta que

identifica al bloque que tiene cargado en ese momento. Una etiqueta es algo que

diferencia a todos los bloques que pueden estar en una misma lnea. Como veremos,

esta etiqueta suele estar formada por los bits ms significativos de la direccin del

bloque en memoria principal..

Cada entrada de la cach tambin debe disponer de un bit V que indique si esa

entrada est ocupada por algn bloque (entrada vlida) o todava no se ha cargado

con ningn bloque desde que se arranc la mquina. Este bit se pone a cero en la



inicializacin de la cach, y se activa cuando se trae un bloque a la lnea por primera

vez.

Cuando un bloque en memoria cach es modificado por una escritura, se debe

marcar para que cuando dicho bloque deba ser sustituido por otro, se actualice su

contenido en memoria principal.

Para ello, cada entrada de cach tambin dispone de un bit de ensuciado,

que al estar activo indica que el bloque ha sido modificado desde que se trajo de

memoria principal.

Poltica de ubicacin

Ya que hay menos entradas o lneas de cach que bloques en memoria

principal, se nos plantea un problema cuando traemos un bloque de memoria a la

cach: Dnde ponemos el bloque? es decir en qu entrada de la cach ponemos el

bloque? De igual manera, al buscar un bloque en la cach, debemos saber dnde

podra estar ubicado este bloque.

Este problema se resuelve segn una poltica de ubicacin. Cada poltica de

ubicacin utiliza una funcin de correspondencia entre las direcciones de los

bloques en memoria principal y sus direcciones en la cach. As, diremos que las

diferentes polticas de ubicacin simplemente utilizan distintas funciones de

correspondencia.

Las tres funciones de correspondencia que se suelen utilizar son las siguientes:

Correspondencia Directa

Correspondencia Asociativa

Correspondencia Asociativa de Conjuntos



A continuacin vamos a tratar con cierto detalle cada una de estas funciones de correspondencia.

Para cada una de ellas veremos su estructura general acompaada de un ejemplo, que en los tres casos supondr lo siguiente:

1. El tamao de la cach es de 4 Kbytes. 2. Los datos se transfieren entre la memoria principal y la cach en bloques de 4

bytes. Esto quiere decir que la cach est organizada en 1024 lneas de 4 bytes cada una.

3. La memoria principal es de 64 Kbytes, pudiendo direccionar a nivel de byte mediante direcciones de 16 bits. Esto quiere decir que, a efectos de la cach, la podemos considerar como una memoria de 16 Kbloques de 4 bytes cada uno.

Correspondencia directa

La funcin ms sencilla de correspondencia es la conocida como

correspondencia directa, segn la cual cada bloque de memoria principal solamente

puede ubicarse en una nica lnea de la cach. La lnea que le corresponde a cada

bloque se obtiene mediante este algoritmo:

Lnea_cach = Nmero_de_bloque mdulo Lneas_en_la cach

En la tabla de arriba pueden verse los bloques de memoria principal que

pueden ubicarse en cada lnea de la cach si son referenciados por la CPU.



Este algoritmo se implementa fcilmente a partir de las direcciones que genera

la CPU. En lo que concierne a la cach, cada direccin de memoria consta de tres

campos:

Desplazamiento: Los d bits menos significativos identifican una nica celda de

memoria dentro de un bloque de memoria principal. Es decir, es el

desplazamiento de la celda dentro de su bloque.

Los restantes b bits de la direccin indican uno de los 2b bloques de memoria

principal. Como todos los bloques de memoria principal no caben en las L lneas

de la cach, sta interpreta estos b bits como una composicin de dos campos:

la lnea y la etiqueta.

Lnea: Este campo indica la lnea en la que debe ubicarse o localizarse un

bloque de memoria principal. Est formado por los l bits menos significativos de

los b bits de mayor peso de la direccin, e indica una de las L lneas de la cach,

pues 2l = L.

Pero claro, va a haber muchos bloques a los que les corresponda la misma lnea

de cach. Concretamente, los restantes b-l bits, los de mayor peso de la

direccin, indican a cuntos bloques les corresponde la misma lnea en la cach.

En la figura de la diapositiva anterior se puede ver que en una cach con L

lneas, a la lnea 0 le corresponden los bloques nmero 0, L, 2L, 3L,...; a la lnea

1 le corresponden los bloques 1, L+1, 2L+1, 3L+1,...; y a la lnea L-1 le

corresponden los bloques L-1, 2L-1, 3L-1,...

Etiqueta: Lo que va a diferenciar a todos los bloques a los que les corresponda

la misma lnea son los b-l bits de mayor peso, esto es, el campo de etiqueta.

Obsrvese que aunque una lnea de cach puede corresponder a varios

bloques, todos esos bloques tendrn una etiqueta distinta.

Cuando la CPU realiza una lectura, la direccin se divide en estos tres campos.

Tomando los b bits del campo de bloque se obtiene el nmero de bloque de memoria

principal. Con el algoritmo arriba indicado se obtiene la lnea que le corresponde al

bloque. Si la lnea no est ocupada, se trae el bloque desde memoria principal a esa

lnea, y con el desplazamiento que indican los d bits de menor peso de la direccin se



obtiene la celda dentro del bloque. Los b-l bits de mayor peso de la direccin deben

ponerse en el campo de etiqueta de la lnea correspondiente de la cach.

En una referencia posterior, cuando se compruebe si el bloque referenciado

est en la cach, si la entrada correspondiente est ocupada, hay que comprobar si el

bloque de esa entrada es el que corresponde a la direccin que se est referenciando.

Para ello simplemente hay que comprobar que el campo de etiqueta de la direccin es

igual a la etiqueta de la lnea que corresponde a ese bloque. Si no es as, habr que

traer el bloque de memoria y sustituir al que estaba en esa lnea. Esto puede

representar un problema.

Veamos un ejemplo de ubicacin mediante correspondencia directa. Para ello, supondremos los siguientes valores:

1. El tamao de la cach es de 4 Kbytes.

2. Los datos se transfieren entre la memoria principal y la cach en bloques de 4 bytes. Esto quiere decir que la cach est organizada en 1024 lneas de 4 bytes cada una.

3. La memoria principal es de 64 Kbytes, pudiendo direccionar a nivel de byte mediante direcciones de 16 bits. Esto quiere decir que, a efectos de la cach, la podemos considerar como una memoria de 16 Kbloques de 4 bytes cada uno.

Veamos el formato de las direcciones. Los 16 Kbloques de la memoria principal

se referencian mediante los 14 bits de ms peso de la direccin; los dos bits de menor

peso constituyen el desplazamiento de la palabra dentro del bloque. En la cach, por

su parte, el nmero de lnea se expresa mediante 10 bits. La ejecucin del algoritmo

de la funcin de correspondencia para averiguar la lnea que le corresponde a un

bloque de memoria (dividir un nmero de 14 bits entre otro de 10 y tomar el resto) es

lo mismo que tomar directamente los 10 bits de menor peso del dividendo, es decir,

del nmero de bloque.

En la parte inferior de la transparencia podemos ver las correspondencias entre

bloques y lneas para este ejemplo.



Las direcciones de memoria estn descompuestas en nmero de bloque y

desplazamiento. El nmero de bloque lo mostramos dividido en dos campos, para ver

claramente la etiqueta de cada bloque y la lnea que le corresponde.

As, podemos ver cmo al bloque 0 le corresponde la lnea 0; al bloque 1, la

lnea 1; y en ltimo lugar, al bloque 3FFF le corresponde la ltima lnea, la 3FF.

Como ya sabamos, al bloque 400 H, tambin le corresponde la lnea 0, pero

como se puede apreciar, el contenido de esta lnea es el del bloque 0, y es razonable,

puesto que la etiqueta de la lnea 0 es la correspondiente al bloque 0, y no la del

bloque 400 H, que tiene una etiqueta 0001.

La tcnica de la correspondencia directa es simple y econmica, pues la

ubicacin se obtiene directamente a partir del algoritmo de la funcin de

correspondencia.

Sin embargo, el problema que presenta la correspondencia directa son las

colisiones; es decir, que a cada lnea de cach (donde slo cabe un bloque) le

corresponden muchos bloques de memoria principal. As, si un programa referencia

repetidamente dos palabras a cuyos bloques les corresponde la misma lnea de la

cach, los dos bloques estarn continuamente expulsndose de la cach, con lo que

la tasa de aciertos descender drsticamente an cuando la cach no est

completamente ocupada.



Correspondencia asociativa

Visto el problema de las colisiones que presenta la correspondencia directa,

veamos otras alternativas

Con la correspondencia asociativa (o completamente asociativa) se

solventan los problemas de la correspondencia directa, pues aqu se permite que cada

bloque de memoria pueda estar en cualquier lnea de la cach, por lo que mientras la

memoria cach no est llena, no habr que hacer ninguna sustitucin. Cuando est

llena y haya que traer un nuevo bloque, habr que sustituir alguno de los bloques

segn la poltica de sustitucin ms apropiada, es decir, la que genere menos faltas de

cach.

Con la correspondencia asociativa, la cach ve cada direccin de memoria

formada solamente por dos campos: el desplazamiento dentro del bloque (los bits

menos significativos) y el nmero de bloque o etiqueta (los ms significativos). Ahora

cada bloque de memoria principal tiene una nica etiqueta posible, que es

precisamente el nmero de bloque.

As, para saber si un bloque est en la cach, su lgica de control debe

comparar la etiqueta de la direccin generada por la CPU con todas las etiquetas de la

cach. Para que estas comparaciones puedan realizarse rpidamente, cada entrada

de la cach cuenta con un comparador, de tal manera que las comparaciones de la

etiqueta de la direccin de memoria con todas las etiquetas de las lneas de la cach

se realizan en paralelo. (Este tipo de memorias se denominan memorias

asociativas).



Con este esquema hay flexibilidad para ubicar un bloque en cualquier lnea de

la cach, y su espacio se puede aprovechar ms eficientemente, pues cuando se trae

un bloque a la cach nunca habr que reemplazar a ninguno de los que ya estaban

cargados a menos que todas las lneas estn ocupadas. Con esta tcnica ya no deben

producirse las repetidas expulsiones mutuas de dos bloques que tenamos con la

correspondencia directa. Los algoritmos de sustitucin que veremos ms adelante se

disearn precisamente para mejorar lo ms posible la tasa de aciertos.

La desventaja obvia de la correspondencia asociativa es el incremento

econmico que genera la electrnica adicional necesaria.

En esta transparencia mostramos la aplicacin de la funcin de

correspondencia asociativa a la arquitectura del ejemplo que estamos utilizando para

ilustrar las polticas de ubicacin.

Como vemos, la direccin de 16 bits ahora solamente se descompone en dos

campos: el desplazamiento, que tiene que seguir siendo de 2 bits, pues lo impone el

tamao del bloque; y el nmero de bloque, de 14 bits, que se utiliza como etiqueta.



Esto quiere decir que en cada lnea de la cach, junto con cada bloque de 4

bytes deben almacenarse tambin los 14 bits de su etiqueta correspondiente.

Ya que esta correspondencia no fuerza ninguna ubicacin concreta para cada

bloque de memoria principal, ya no hay colisiones como en la correspondencia directa,

sino que al traer un bloque a la cach, si sta est totalmente ocupada, simplemente

debe sustituirse alguno de los bloques que ya estaban por el recin trado. Puesto que

no se fija de antemano cul debe ser el bloque a sustituir, no se corre el peligro de la

correspondencia directa, en la que poda darse el caso de tener que sustituir un bloque

que se estaba referenciando muy a menudo. La poltica de sustitucin se encargar de

elegir el bloque que al ser sustituido genere el menor perjuicio posible a la tasa de

aciertos de la cach.

Como se muestra en el ejemplo, con esta correspondencia se consigue que,

normalmente, los ltimos bloques referenciados por la CPU se encuentren en la

cach, sin que uno de ellos haya tenido que expulsar a otro recientemente

referenciado para cargarse en la cach.

Correspondencia asociativa de conjuntos

La correspondencia asociativa de conjuntos combina la economa de la

correspondencia directa con la tasa de aciertos de la correspondencia asociativa.

Consiste en agrupar las lneas de la cach en conjuntos, de tal forma que la funcin de

correspondencia permita que un bloque de la memoria principal pueda ubicarse en

cualquier lnea de un conjunto concreto.

Con esta poltica, la memoria cach se divide en C conjuntos de L lneas cada

uno. As, el nmero M de lneas de la cach es M = C x L.

De forma similar a la correspondencia directa, para averiguar el conjunto c de

la cach que le corresponde a un cierto bloque b de memoria principal, se aplica la

siguiente correspondencia:

c = b mdulo C

Una vez averiguado el conjunto c de la cach que le corresponde al bloque b,

ste puede ubicarse en cualquiera de las lneas del conjunto c.



Tambin de manera equivalente a la correspondencia directa, cuando la CPU

suministra una direccin para acceder a la memoria principal, la direccin se

descompone en dos campos: bloque y desplazamiento. Ya que todos los bloques de

memoria principal no caben en la cach, el campo bloque se divide, a su vez, en otros

dos campos: conjunto y etiqueta. Ya sabemos que la operacin nmero mdulo 2n es

lo mismo que tomar los n bits de menor peso del nmero, por lo que el conjunto

asignado a un bloque de memoria se obtiene con los c bits siguientes al

desplazamiento. Por ltimo, los bits restantes (los de mayor peso) forman la etiqueta.

Un bloque de memoria solamente puede estar en un conjunto de la cach, pero

dentro del conjunto hay varios bloques, por sto es necesario disponer de la etiqueta,

pues no puede haber dos bloques del mismo conjunto con la misma etiqueta.

Obsrvese que si el nmero de lneas por conjunto se lleva a los casos

extremos, se da lugar a las otras dos correspondencias que hemos visto. Cuando el

nmero de lneas por conjunto es 1, se est en el caso de la correspondencia directa;

mientras que si la cach est formada por un nico conjunto que contiene todas las

lneas de la cach, se trata de una correspondencia completamente asociativa.

Normalmente se suelen utilizar 2 lneas por conjunto (memoria asociativa de

dos vas), lo cual mejora notablemente la tasa de aciertos de la correspondencia

directa. A medida que se aumenta el nmero de lneas por conjunto, aumenta el coste

de la memoria pero sin conseguir una mejora significativa.

Con esta tcnica se disminuye mucho el coste de la electrnica adicional de la

correspondencia asociativa, pues mientras que en sta se requieren tantos

comparadores como lneas, en la asociativa de conjunto de dos vas, solamente

son necesarios dos comparadores.



Veamos ahora cmo aplicar la correspondencia asociativa de conjuntos a

nuestro ejemplo tipo.

Ahora la direccin de 16 bits vuelve a descomponerse en tres campos. El

desplazamiento sigue estando indicado por los dos bits de menor peso, puesto que los

bloques siguen siendo de 4 palabras. En cuanto al nmero de bloque, queda indicado

por los 14 bits de mayor peso, aunque en este caso, para conocer la ubicacin de

cada bloque en la cach solamente necesitamos los 8 bits de menor peso del nmero

de bloque, que es el resultado de la operacin Num_Bloque mdulo

Num_Conjuntos. As, tenemos que los bloques con nmero 0, 100H, 200H, etc.,

deben ubicarse en el conjunto 0 de la cach; los que tienen nmero 1, 101H, 201H,

etc., corresponden al conjunto 1, y as sucesivamente.

Al igual que en la correspondencia directa, nos encontramos con que hay

colisiones, es decir, hay muchos bloques que les corresponde el mismo conjunto. Sin

embargo, mientras que en la correspondencia directa solamente poda haber un

bloque en una direccin, ahora tenemos que en una misma direccin de la cach



puede haber tantos bloques como permita el tamao del conjunto. En nuestro ejemplo

los conjuntos son de 4 bloques, como el Motorola 68040 y el

PowerPC 604, que tambin utilizan una memoria asociativa con conjuntos de 4

bloques (memoria asociativa de conjuntos de 4 vas). Los Pentium, sin embargo,

disponen de una cach asociativa de conjuntos de 2 vas.

Volviendo a nuestro ejemplo, podemos ver que al primer bloque de memoria

principal (el bloque 0) le corresponde el conjunto 0 de la cach, y al segundo bloque, el

conjunto 1. Como ya sabamos, nos encontramos con que al bloque 100H tambin le

corresponde el conjunto 0, pero en esta ocasin, para cargar el bloque 100H no hay

que expulsar al bloque 0 (como suceda en la correspondencia directa), ya que ahora

en cada conjunto se pueden ubicar hasta 4 de los bloques a los que la funcin de

correspondencia otorga la misma direccin. Para diferenciar los distintos bloques que

corresponden al mismo conjunto se utiliza la etiqueta de 6 bits que tiene cada bloque.

No puede haber dos bloques con la misma etiqueta que les corresponda el

mismo conjunto.

De esta manera se evita en gran medida el problema de la correspondencia

directa, en la que dos bloques muy usados en un bucle podan estar expulsndose

mutuamente, desaprovechando as la eficacia de la memoria cach.

Poltica De Sustitucin

Cuando se produce una falta de cach y hay que traer el bloque desde

memoria principal, si no hay una lnea libre para el bloque, habr que sustituir alguno

de los que estn en la cach por el recin referenciado.

Si se utiliza correspondencia directa, no hay ninguna eleccin, hay que sustituir

el bloque de la nica lnea en la que se puede ubicar el bloque referenciado. Si se trata

de correspondencia asociativa de conjuntos, se puede elegir entre cualquiera de los

bloques del conjunto que le corresponde al bloque referenciado. Y si la funcin de

correspondencia es la completamente asociativa, se puede elegir para sustituir

cualquiera de los bloques que estn en la cach. As, tenemos que en los dos ltimos

tipos de correspondencias necesitamos una poltica de sustitucin. Esta cuestin es

extremadamente importante, pues la poltica utilizada es un factor determinante para la

tasa de aciertos del sistema.



Hay dos enfoques a la hora de elegir una poltica de sustitucin: el que tiene en

cuenta la estadstica de utilizacin de los bloques (la historia de uso), y el que no lo

tiene en cuenta. Entre los primeros se encuentran las polticas LRU y LFU, y como

representantes del segundo enfoque est la poltica random y la FIFO.

LRU (Least Recently Used). En general, el objetivo es mantener en la cach

los bloques que tienen ms probabilidades de ser accedidos en un futuro prximo,

pero no resulta nada fcil saber esto. No obstante, el principio de localidad nos dice

que en ciertas reas de memoria, y durante un periodo razonable de tiempo, hay una

alta probabilidad de que los bloques que acaban de ser referenciados recientemente

sean referenciados otra vez en un futuro prximo. Por eso, cuando hay que

seleccionar un bloque vctima, parece razonable elegir el que lleva ms tiempo sin ser

referenciado (el menos recientemente referenciado, the least recently used).

Como hemos dicho con esta poltica se desaloja de la cach el bloque que

tiene ms tiempo sin usarse. En su implementacin por hardware cada vez que se usa

un bloque se debe almacenar alguna referencia al tiempo (timestamp)y por lo tanto se

sustituye aquel bloque que tenga la referencia ms antigua.

Esta poltica de sustitucin falla cuando se est accediendo de forma

secuencial y cclica a elementos de una matriz que no cabe completamente en la

cach.

Una poltica parecida es la LFU (Least Frequently Used), (utilizado menos

frecuentemente): Se sustituye aquel bloque que ha experimentado menos referencias.

En su implementacin: cada bloque posee un contador, el que se incrementa

cada vez que el bloque ha sido referenciado. Se sustituye aquel que tenga el contador

ms bajo. en la cual se sustituye el bloque menos referenciado. sta tambin se

implementa con ayuda de contadores.

Como polticas no basadas en la estadstica de uso, tenemos la FIFO (First In,

First Out) que ofrece unos resultados ligeramente inferiores a la LRU. Se hace una

lista con la secuencia de entrada de los bloques a la memoria cach. Se desaloja el

bloque ms antiguo.

Para su implementacin con ayuda de un buffer circular (una lista circular) con

una manecilla que indica el ms antiguo.

Hay que tener en cuenta que no se desaloja el bloque cuyo uso sea el ms

antiguo (eso es LRU), se desaloja aquella que su ingreso a la cach es el ms antiguo.

Es decir se sustituye aquel bloque que ha estado ms tiempo en la cach (an cuando

se haya usado recientemente)

Los problemas que presenta se deben al hecho de que solamente tiene en

cuenta el tiempo que lleva un bloque en la cach, y no cules han sido las ltimas

referencias; por esto tambin puede fallar con algunas matrices.

La poltica Random, se sustituye un bloque cualquiera segn una funcin

aleatoria.

Estudios realizados mediante simulacin han mostrado que la sustitucin

aleatoria proporciona un desempeo ligeramente menor a un algoritmo de reemplazo

como los anteriores (basados en el grado de utilizacin).

Por lo tanto, ofrece una buena tasa de aciertos, no tiene el problema de la LRU

con las matrices, y es fcil y econmico de implementar.



Poltica De Actualizacin

El problema de la coherencia de cachs tiene que ver con la poltica de

actualizacin.

Aqu hay dos situaciones a considerar. En un ordenador puede haber ms de

un elemento que acceda a la memoria principal, pues en un ordenador actual no es

raro encontrarnos con varias CPUs o, simplemente, los dispositivos de entrada/salida

gobernados directamente desde alguna CPU o a travs del controlador de DMA.

Segn esto, cuando desde una CPU se modifica un dato en su cach, el

correspondiente dato en memoria principal queda obsoleto, con lo que si desde otra

CPU o dispositivo se accede al dato original en memoria principal, resulta que se

accede a un dato que no est actualizado. Tambin puede suceder que sea un

dispositivo de entrada el que modifica el dato en memoria principal con un nuevo valor,

con lo que entonces es el dato de la cach el que queda obsoleto.

Esto es lo que se conoce como el problema de la coherencia de las cachs.



El problema de coherencia de las cachs depende de la poltica de escritura

o actualizacin que se utilice.

La tcnica ms simple es la escritura o copia inmediata (write through),

segn la cual todas las escrituras se realizan tanto en la cach como en la memoria

principal, asegurando as que la memoria principal siempre est actualizada, lo cual

simplifica el problema de la coherencia en entornos multiprocesadores. El

inconveniente que presenta es el trfico que genera en los buses del sistema. Podra

pensarse que tambin supone una sobrecarga de tiempo, puesto que adems de

escribir en la cach, hay que escribir tambin en la memoria principal, pero est ltima

operacin puede realizarse en paralelo con la escritura en memoria cach o con otras

actividades por lo que, en la prctica, no supone un tiempo adicional.

La otra alternativa es la escritura o copia diferida (copy back), en la cual una

operacin de escritura solamente escribe en la cach.

En esta ltima alternativa, cuando se escribe o actualiza un bloque de la cach,

se activa el bit modificado (dirty bit) asociado a esa lnea, de tal manera que cuando

hay que reemplazar un bloque, si su bit modificado est activado entonces el bloque

debe actualizarse en memoria principal, por lo que hay que escribirlo en ella antes de

ocupar la lnea de la cach con el nuevo bloque. El problema que tiene es que, en un

momento dado, hay datos en memoria principal que no estn actualizados, lo cual

puede originar problemas de coherencia de datos.

Tamao de la cach

Adems de las cuestiones generales que hemos tratado, hay otras

consideraciones que se deben tener en cuenta en el diseo de una memoria cach: el

tamao total de la memoria cach y el tamao de cada bloque.

Tamao de la cach. Ya hemos comentado que nos gustara que el tamao de la

cach fuera lo suficientemente pequeo como para que el coste medio por bit de

memoria total (cach ms memoria principal) fuera muy cercano al de la memoria

principal, y lo suficientemente grande como para que el tiempo medio de acceso a

memoria fuera casi el mismo que el tiempo de acceso a la cach.



Cuanto ms grande sea la cach, mayor es el nmero de puertas necesarias

para su direccionamiento, por lo que las grandes cachs tienden a ser ligeramente

ms lentas que las pequeas.

Por el principio de localidad temporal, a mayor nmero de lneas de cach,

mayor probabilidad de acierto. No obstante, un programa solamente direcciona unas

cuantas reas de memoria durante un cierto intervalo de tiempo, por lo que a partir de

un cierto nmero de lneas, no se mejorar la tasa de aciertos.

Las prestaciones de la cach dependen mucho de las caractersticas del

programa en ejecucin, por lo que no se puede establecer un tamao ptimo, aunque

algunos estudios estadsticos sugieren que el tamao ptimo de la cach debe estar

entre 1 y 512 Kbytes.

En la tabla superior se muestra el tamao de la cach de algunos procesadores

populares de propsito general.

Tngase en cuenta que en casi todos los modelos presentados aqu ha habido

diversas versiones o variantes con distintas configuraciones, tanto de velocidad del

reloj, de nmero de ncleos y, por supuesto, con diversas opciones de cantidad de

memoria cach. No obstante, lo presentado aqu puede dar una idea de la evolucin

que ha ido teniendo el tamao de la memoria cach.

Los procesadores de hoy da suelen tener una memoria cach organizada en

tres niveles. En el nivel 1, cada ncleo cuenta con su propia cach (L1), y suele estar

compuesta por dos memorias separadas para datos (DCU) y para instrucciones (ICU).

La cach de nivel 2 (L2 o Mid Level Cache) tambin es independiente para cada

ncleo, pero combina instrucciones y datos. Por ltimo, la cach de nivel 3 (L3 o Last

Level Cache) es una nica memoria compartida entre todos los ncleos del

procesador.



Tamao de bloque. Cuando se trae un bloque a la cach no solo se trae la

palabra referenciada, sino tambin unas cuantas adyacentes. As, debido al principio

de localidad espacial, a medida que el tamao del bloque aumenta, tambin aumenta

la probabilidad de acierto. Sin embargo, esta probabilidad empezar a disminuir si el

tamao del bloque crece hasta el punto de que la probabilidad de acceder a otras

palabras del bloque sea menor que la probabilidad de reutilizar la informacin que hay

que reemplazar al traer un bloque grande a la cach.

Estas son las consecuencias negativas de los bloques de gran tamao:

1. Al ser los bloques ms grandes, se reduce el nmero de bloques de la cach. Ya que cada bloque que se trae a la cach reemplaza a otro, si tenemos pocos bloques en la cach la frecuencia de sustituciones de bloques ser muy alta, es decir, que un bloque se reemplazar poco despus de haberse cargado, lo cual, segn el principio de localidad, no es nada bueno.

2. A medida que el tamao del bloque se hace mayor, cada palabra adicional est ms alejada de la que se ha referenciado, por lo que tiene menor probabilidad de ser requerida en un futuro prximo.

3. Cuando se trae un bloque a la cach desde la memoria principal, cuanto mayor sea el bloque, ms tiempo se tarda en leerlo.

Hoy da, el tamao del bloque de cach est alrededor de 64 bytes.



Una forma de evaluar los beneficios de las diferentes organizaciones de una

cach es midiendo la tasa de fallos, es decir, el nmero de fallos en los accesos,

dividido por el nmero total de accesos.

La causas de los fallos de cach se pueden clasificar en estas tres categoras:

Obligatorias: En el primer acceso a un bloque, ste nunca puede estar en la

cach, por lo que debe traerse a cach desde memoria principal. Estos fallos

son obligatorios y se producen independientemente del tamao de la cach

(incluso aunque fuera infinita).

Por capacidad: Si la cach no puede contener todos los bloques necesarios

para la ejecucin de un programa se producen fallos, porque algunos bloques

sern expulsados y ms tarde volvern a ser referenciados y recuperados.

Por conflicto: Si la poltica de ubicacin no es completamente asociativa

(correspondencia directa o de conjuntos), habr fallos desafortunados, pues

aun habiendo lneas libres en la cach, se pueden producir colisiones, es

decir, que al traer un bloque a la cach se le asigna la lnea de otro bloque

que ya estaba en la cach, con lo que este ltimo ser expulsado, y ms

tarde puede que vuelva a ser referenciado (con el consiguiente fallo de

cach).

En las siguientes pginas veremos algunas estrategias que ayudan a mejorar

estos problemas de los fallos de cach.



Vamos a mostrar aqu algunas mejoras sencillas que se pueden realizar en el

diseo de una cach para mejorar la tasa de fallos. En las siguientes pginas se

abordarn otras mejoras de diseo ms avanzado.

La manera ms simple de reducir la tasa de fallos es aumentar el tamao del

bloque para aprovechar el principio de localidad espacial. Con bloques ms grandes

se reducen los fallos obligatorios (los de carga inicial), pero, ante un fallo de cach, se

incrementa el tiempo de acceso para traer a cach el bloque referenciado.

La forma obvia de reducir los fallos debidos a la capacidad de la cach es

aumentar el tamao de la cach. No obstante, debe tenerse en cuenta que a medida

que aumenta la capacidad de una memoria, tambin aumenta su tiempo de acceso,

as como el coste y el consumo.

Cuanto ms asociativa sea una memoria (totalmente asociativa o asociativa

de conjuntos) menor ser su tasa de fallos por conflictos (colisiones en la ubicacin).

No obstante, las memoria asociativas tambin tienen una mayor penalizacin en el

tiempo de acceso (en los aciertos), y su precio es ms elevado.

Es difcil decidir si se mejora el tiempo de acceso a la cach para seguir el

ritmo de los procesadores con un reloj cada vez ms rpido, o disponer de una cach

mayor para evitar los accesos a memoria principal. La solucin a esta disyuntiva

consiste en tener dos niveles de cach. La cach de primer nivel (L1) puede ser

suficientemente pequea como para mantener una buena velocidad, mientras que la

de segundo nivel (L2) puede ser suficientemente grande como para evitar muchos

accesos que tendran que ir a memoria principal. As, en la cach de nivel 2, se tiende

a una mayor capacidad, bloques grandes y muy asociativa (ms vas).



En las siguientes pginas vamos a tratar algunas vas ms para mejorar el

tiempo medio de acceso a la cach.

El tiempo medio de acceso a una memoria cach se basa en estos tres

factores: tiempo de acceso (en acierto), tasa de fallos y el tiempo de penalizacin por

fallo. Para los procesadores superescalares de hoy da, debemos aadir un factor

ms: el ancho de banda.

As pues, vamos a organizar las mejoras en las siguientes categoras:

Reducir el tiempo de acceso (en acierto), mediante cachs pequeas y simples, prediccin dela va (para cachs asociativas de conjuntos) y cachs de trazas.

Reducir la penalizacin por fallo mediante la tcnicas de la palabra crtica, primero, as como aumentando el paralelismo: prealimentacin por hardware y en compilacin.

Reducir la tasa de fallos, con ayuda de optimizaciones en el compilador.

Incrementar el ancho de banda mediante cachs segmentadas, multibanco y no bloqueantes.



Como se puede apreciar en el grfico de arriba, el tiempo de acceso a las

memorias cach crece a medida que aumenta su tamao, especialmente a partir de

los 256 KBytes. Como vemos, tambin es mayor el tiempo de acceso para las

memorias de correspondencia asociativa de conjuntos (2, 4 y 8 vas) que para las de

simple correspondencia directa (una va).

Por una parte, es que el hardware ms pequeo es ms rpido, es decir, una

memoria de menor capacidad requiere menos circuitos para el clculo de direcciones,

con lo que acaba siendo ms rpida.

Por otra parte, tenemos que una gran parte del tiempo de acceso a una cach

se debe al tiempo empleado en la comprobacin de si el bloque referenciado est en

la memoria cach, es decir, en la comparacin de la parte de etiqueta de la direccin

referenciada con la correspondiente etiqueta de las lneas de la cach. Por esto,

cuanto ms simple sea la poltica de ubicacin, menor tiempo se requerir para la

comprobacin. La correspondencia directa es la ms sencilla y, adems, se puede

solapar en el tiempo la comprobacin de la etiqueta con el envo del bloque; en caso

de fallo, se desecha el bloque.

No obstante, una cach pequea tambin genera una mayor tasa de fallos, por

lo que se requiere otra cach mayor (la de nivel2) que ayude a evitar un acceso

frecuente a la memoria principal. El tamao de esta cach L2 deber ser lo

suficientemente pequeo como para que pueda mantenerse dentro del mismo chip del

procesador, para mantener as la mxima velocidad en el acceso.

Aunque la capacidad de la cach del chip del procesador (on-chip cach) ha

ido aumentando progresivamente, el tamao de la L1 se va mantiene entre varias

generaciones de procesadores, pues el nfasis se hace en mantener la creciente

frecuencia del reloj.



En un ordenador con un sistema de memoria con una cach de dos niveles (L1

Y L2), cuando el procesador realiza un acceso a memoria, el dato se acabar

obteniendo de uno de estos tres lugares:

Cach L1 Cach L2 Memoria principal

As, en el clculo del tiempo medio de acceso (Tmedio) a memoria, habr que

sumar los tiempos de acceso a cada una de las tres memorias (L1, L2, MP)

considerando la probabilidad de que el acceso se acabe realizando a cada una de

ellas.

TL1: tiempo de acceso a la cach de nivel 1

TL2: tiempo de acceso a la cach de nivel 2

TMP: tiempo de acceso a la memoria principal

PAL1: probabilidad de acierto en el acceso a la cach de nivel 1

PAL2: probabilidad de acierto en el acceso a la cach de nivel 2

Recordamos que la probabilidad de fallo en un acceso es el complemento a 1 de la probabilidad de acierto, es decir, que

PFallo = 1-PAcierto

Sabemos que la correspondencia directa es la ms simple y, por lo tanto, ms

rpida, aunque tambin sabemos que la correspondencia asociativa (o la de

conjuntos) aprovecha ms la capacidad de la cach, no expulsa bloques cuando hay

lneas libres.

Con esta mejora (prediccin de la va) se pretende utilizar una memoria

asociativa de conjuntos consiguiendo la rapidez de acceso de la correspondencia

directa. Para ello, lo que se hace es predecir cul es la va de la cach en la que est

el bloque buscado. La comparacin de la etiqueta del bloque se hace en paralelo con

la lectura de los datos del bloque, todo ello en el mismo ciclo de reloj. Si al prediccin

acierta, la latencia de acceso ser la ms rpida posible; si la prediccin falla, ser

necesario otro ciclo de reloj para comprobar la etiqueta de otro de los bloques.



Para la implementacin de este mecanismo se le aaden unos bits de

prediccin a cada bloque de la cach. Cuando se acierta en una prediccin, los bits del

bloque elegido se establecen con la mayor probabilidad; si se falla, se busca otro

bloque hasta que se encuentra (si es que est en la cach) y a continuacin se

cambian convenientemente los valores de los bits de prediccin.

Segn las simulaciones, la prediccin de la va tiene una tasa de acierto de

alrededor del 85% para una cach de dos vas, es decir, que ahorra ciclos de reloj en

el 85% de los accesos a memoria.

Cachs compartidas o separadas

Los diseos de los primeros sistemas que incluyeron memoria cach disponan de una nica cach para almacenar tanto operandos como instrucciones.

Hay dos ventajas potenciales en mantener la cach unificada:

1. Para un tamao de cach dado, la versin unificada ofrece una mayor tasa de aciertos que la dividida, ya que se establece automticamente el equilibrio necesario entre el espacio utilizado para las instrucciones y para los datos (operandos). Es decir, que si, por ejemplo, un modelo de ejecucin tiende a realizar ms referencias a instrucciones que a datos, la cach tender a llenarse con ms instrucciones que con datos.

2. Es mucho ms simple de disear e implementar una cach compartida.

A pesar de estas ventajas, los potentes procesadores segmentados de hoy da

tienden a utilizar cachs de nivel 1 (L1) separadas o divididas (arquitectura Harvard):

una dedicada a instrucciones y otra a los datos u operandos, pues al disponer de la

lectura adelantada de instrucciones (prefetching) y de ejecucin segmentada de las

instrucciones (pipeline), con cachs separadas se permite el acceso simultneo, pues

se puede acceder a un dato al mismo tiempo que la unidad de prefetching extrae la

siguiente instruccin.



Como sabemos, la frecuencia del reloj de los procesadores va aumentando,

por lo que el ciclo es cada vez menor. Sin embargo el tiempo de acceso a la memoria,

por desgracia no consigue seguir el ritmo de los procesadores. Esto quiere decir que si

un acceso a cach antes se poda realizar en un solo ciclo de reloj, ahora requiere

varios ciclos, con lo que la duracin de una instruccin ahora requiere ms ciclos de

reloj para completarse.

Para mejorar esta situacin, lo que se puede hacer es segmentar loa accesos a

la memoria cach tal como se muestra en el grfico, de tal manera que aunque un

acceso completo pueda requerir 3 ciclos (por ejemplo), lo que se hace es arrancar una

lectura a cada ciclo de reloj, con lo que, a la larga, se consigue que al final de cada

ciclo, finalice un acceso a la cach.

En los ordenadores segmentados (en pipeline) que permiten la ejecucin fuera

de orden, el procesador no se detiene ante un fallo de cach. Por ejemplo, el

procesador puede continuar extrayendo instrucciones de la cach de instrucciones

mientras espera a que la cach de datos le devuelva un dato despus de un fallo.

Una cach no bloqueante permite que se continen devolviendo datos de

accesos con acierto, mientras se espera a que se consiga el dato que provoc un fallo.

Esta mejora reduce la penalizacin por fallo, pues, ante un fallo, contina

aceptando peticiones del procesador en lugar ignorarlas hasta que se resuelva el fallo.



Una mejora adicional, aunque compleja, consiste en permitir mltiples fallos

solapados, es decir que ante un fallo, al atender otra peticin del procesador, se puede

producir un fallo ms y, an as, seguir aceptando peticiones del procesador.

En general, los procesadores fuera de orden son capaces de camuflar la

mayora de los fallos de las cachs L1 que consiguen acierto en la de nivel 2, pero no

son capaces hacerlo con la mayora de los accesos que suponen un fallo en la cach

L2.

En una memoria de un banco, los accesos deben realizarse de manera

secuencial de uno en uno. Es decir, no se permiten los accesos mltiples y

simultneos.

En una memoria de mltiples bancos, cada banco tiene asignado un rango de

direcciones de memoria.

Una memoria de n bancos permite n accesos simultneos a la memoria,

siempre que las direcciones pertenezcan a bancos distintos.

En las cachs, en lugar de tratar cada cach como un bloque monoltico, se

puede dividir en bancos independientes que soporten mltiples accesos simultneos.

Las memorias multibanco trabajan mejor cuando los accesos estn distribuidos

entre los bancos. Una distribucin de las lneas de la cach, que funciona bien,

consiste en distribuir las direcciones de manera secuencial y alterna. En el ejemplo de

arriba se muestra la distribucin secuencial alterna.

Los bancos de memoria se utilizaron inicialmente para mejorar las prestaciones

de la memoria principal. Ahora se utilizan tanto en las actuales memorias DRAM como

en las cachs.

A modo de ejemplo, diremos que la cach L2 del AMD Opteron tiene 2 bancos.

El ordenador Niagara, de Sun, tiene una cach L2 con 4 bancos. Una cach no

debera tener ms bancos que el nmero mximo de accesos simultneos que pueda

requerir por parte del procesador.



Las cachs de actualizacin o escritura inmediata (write-through) se apoyan en

buffers de escritura, ya que todos los datos a almacenar deben enviarse al siguiente

nivel de la jerarqua de memoria (cach L2 o memoria principal).

Cuando se ejecuta una instruccin store, si el buffer de escritura tiene una

entrada libre, el dato junto con su direccin se escriben en el buffer y, desde el punto

de vista del procesador, la escritura ha finalizado. A partir de ah, mientras el

procesador contina trabajando, el controlador de memoria se ocupa de escribir el

dato del buffer en memoria principal o cach L2. Si el buffer est lleno, el procesador

debe esperar a que quede una entrada libre en el buffer.

El tamao del buffer suele ser de 4 entradas, y se gestiona mediante una

poltica FIFO.

Obviamente, el buffer de escritura ofrece un buen resultado cuando la

frecuencia de las escrituras es menor que 1/TMP, (TMP: tiempo de acceso a memoria

principal).

El buffer de escritura se utiliza tambin con las memorias de escritura diferida

(write-back).



En una cach [de escritura o actualizacin diferida (write-back)], cuando se

debe hacer una sustitucin de bloque, al bloque expulsado se le conoce como vctima.

Esta vctima debe escribirse entonces en memoria principal o cach L2, por lo que el

bloque seleccionado se escribe en el buffer de escritura. Por eso, en el caso de las

cachs de escritura diferida, al buffer de escritura se le conoce como buffer de

vctimas o cach de vctimas.

La cach de vctimas, por tanto, contiene los bloques que se han expulsado de

la cach ante un fallo y una falta de lnea libre, que fuerza una sustitucin.

En las cachs de escritura diferida, los bloques que por una sustitucin son

expulsados y no han sido modificados (estn limpios) no se escriben en memoria

principal o L2, simplemente se expulsan y se desechan. Sin embargo, cuando se

dispone de un buffer o cach de vctimas, todos los bloques expulsados se meten en

la cach de vctimas, pues ante una fallo de cach L1, se comprueba el contenido del

buffer de vctimas para ver si el bloque deseado todava se encuentra en dicho buffer.

En caso afirmativo, se toma el bloque del buffer, evitando as la peticin del dato a la

cach L2 o a memoria principal.

El propsito del buffer de escritura es permitir que el acceso a la cach prosiga

sin tener que esperar a que los bloques sucios se escriban en memoria. Sin

embargo, el objetivo de la cach de vctimas es reducir el impacto de las sustituciones

de bloques.

Hoy da, los buffers de escritura son bastante ms populares que las cachs de

vctimas.

Ya hemos visto los beneficios del buffer de escritura y del buffer de vctimas.

Vamos a continuar sacando provecho de l.

Cuando el procesador arranca una escritura en memoria, se comprueba si la

direccin de escritura pertenece al rango de direcciones de alguno de los bloques del

buffer de escritura, y si es as se copia el dato a ese bloque del buffer de escritura. Si,

en cambio, el buffer no contiene el bloque correspondiente al dato a escribir, se utiliza

una entrada libre del buffer para poner en l el bloque completo con el nuevo dato a

escribir.



De esta manera, la escritura de dos o ms datos que pertenezcan al mismo

bloque, se pueden refundir en una nica operacin de escritura en memoria, la

escritura del bloque. Sin write merging, cada escritura de un dato generara su

correspondiente escritura en memoria (de bloques completos).

Visto el concepto, write merging podra traducirse por fusin en escritura,

escritura combinada o algo parecido, pues lo que se hace es fusionar o combinar las

escrituras de varios datos en una nica escritura del bloque que contiene todos esos

datos.

Teniendo en cuenta que cada escritura en memoria es de un bloque completo

aunque el procesador solo quiera modificar un dato simple (un byte, por ejemplo), esta

mejora tambin reduce las paradas del procesador, pues aprovecha ms las

escrituras, ya que cada bloque que se escribe contiene ms datos modificados, pues

cuando no hay write merging, cada peticin de escritura del procesador (de un dato

simple) genera la ocupacin de una entrada completa (para un bloque completo) en el

buffer de escritura.

Esta mejora para reducir la penalizacin ante un fallo de cach est basada en

la observacin de que, normalmente, el procesador realiza lecturas de un byte o una

palabra, no de un bloque completo. As, la estrategia de esta optimizacin es la

impaciencia: cuando el procesador encarga la lectura de una palabra, no se espera a

tener el bloque completo cargado en la cach para entregar la palabra solicitada, en

cuanto se tenga la palabra requerida por el procesador, se entrega y se continua la

ejecucin mientras, en paralelo, se carga el bloque completo en la cach.

Para hacer esto hay dos estrategias:

La palabra crtica, primero. Ante un fallo de cach, se carga primero la palabra solicitada y se le enva al procesador. El procesador contina la ejecucin mientras se carga el resto del bloque en la cach. Parecido a esto es la carga directa, en la que la palabra solicitada se lleva al procesador en paralelo con la carga del bloque completo en la cach.

Rearranque rpido. En este enfoque, las palabras del bloque se van leyendo de memoria en orden normal (secuencial), pero tan pronto como llega la palabra solicitada por el procesador, se le enva para que prosiga la ejecucin mientras se carga el resto del bloque en la cach.



Generalmente, estas tcnicas solo son eficaces en diseos en cachs con

bloques grandes, pues la diferencia entre cargar una palabra o el bloque completo, es

menor cuanto ms pequeo sea el bloque (hasta que el tamao del bloque es igual al

del bus de datos).

Tambin debemos recordar que en las cachs no bloqueantes, ante un fallo de

cach, la cach sigue operativa mientras se carga el bloque del fallo, por lo que el

procesador puede continuar su ejecucin si sta es fuera de orden.

Las tcnicas utilizadas hasta ahora para mejorar las prestaciones de la cach

han requerido cambios en el hardware; ahora lo haremos modificando el software, esto

es, con optimizaciones en el compilador, para que organice mejor la disposicin del

cdigo y los datos, de tal manera que se minimicen las faltas de cach.

Veamos tres ejemplos de cmo se puede reorganizar el cdigo sin afectar a la

semntica del programa.

Se puede hacer que cada rutina del programa se ubique al comienzo de un bloque, con lo que, si el cdigo es secuencial, disminuye la posibilidad de un fallo en la cach de cdigo.

Otra mejora consiste en que si el compilador sabe qu rama de una bifurcacin va a ser la ms tomada, puede cambiar el sentido de la bifurcacin (y sus respectivos bloques de cdigo) de tal manera que el bloque de la rama ms tomada est ubicado en secuencia, para no tener que saltar a otro punto de la memoria, lo que originara seguramente un fallo de cach.

El clculo con matrices es la causa de una gran parte de los fallos de cach. Los datos de una matriz estn organizados por filas y columnas, y para operar con todos sus elementos, se puede recorrer por filas (primero todos los elementos de una fila, luego los de la siguiente) o por columnas (primero todos los elementos de una columna, luego los de la siguiente). Pues bien, si la matriz no cabe en la cach y ocupa varios bloques y suponemos que, por ejemplo, los datos estn organizados por filas, es preferible recorrer la matriz por filas que por columnas, pues de hacerlo por columnas, cada acceso secuencial en el tiempo se hara a elementos muy separados en el espacio, con la consecuente mayor probabilidad de fallo.



Otra forma de reducir la penalizacin por fallo de cach consiste en alimentar

datos e instrucciones antes de que sean requeridos por el procesador. Los datos o

instrucciones pre-alimentados se pueden llevar directamente a la cach o a un buffer

externo que sea ms rpido que la memoria principal.

La pre-alimentacin de instrucciones se suele realizar por medio de un

hardware externo a la cach. Ante un fallo de cach (de instrucciones), el bloque

solicitado se pone en la cach de instrucciones, y el siguiente bloque en secuencia se

coloca (se pre-alimenta) en un buffer de instrucciones. As, cuando hay un fallo,

primero se comprueba si el bloque requerido est en el buffer de instrucciones. Si

est, se lleva a la cach y se cancela la peticin a memoria; si no est en el buffer, se

carga ese bloque y el siguiente como se ha indicado antes.

El mecanismo de pre-alimentacin de datos es similar al de instrucciones.



Una alternativa al prefetch por hardware es que sea el compilador el que

inserte instrucciones prefetch para forzar la carga de datos en cach antes de que los

necesite el procesador.

Al igual que en el prefetch hardware, el objetivo es solapar la ejecucin con la

pre-carga de datos, de tal manera que cuando el procesador realice un acceso a esos

datos, ya estn cargados en cach, evitando as el fallo de cach.

Este prefetch software solo tiene sentido si el procesador puede continuar la

ejecucin al mismo tiempo que se est pre-cargando datos, es decir, que las cachs

no se bloquean durante la precarga, y continan proporcionando instrucciones y datos

mientras esperan los datos solicitados de pre-carga. Esto quiere decir que las

memorias cach deben ser no bloqueantes.

Hay que tener en cuenta que la emisin de instrucciones prefetch supone una

sobrecarga para el procesador, por lo que los compiladores deben tener mucho

cuidado de asegurarse de que esta sobrecarga no sea mayor que el beneficio

obtenido de la precarga de las instrucciones.

Los bucles son los fragmentos de cdigo que ms se prestan a obtener

beneficios de las precargas.

Arriba a la izquierda tenemos un fragmento de cdigo en el que se realiza un

cierto clculo con los elementos de una matriz. El compilador, al analizar el cdigo

calcular los puntos en los que debe insertar instrucciones PREFETCH para forzar la

pre-carga de datos que utilizar en un futuro prximo.

El tiempo necesario para la pre-carga debe calcularse bien pues, de lo

contrario, un bloque cargado con demasiada antelacin, podra resultar expulsado

antes de acceder a l, si se produce una colisin con otro bloque que sea referenciado

por el procesador. Si, por el contrario, el bloque no se ha cargado todava cuando el

procesador requiere el acceso, se producira un fallo de cach; justo lo que se quiere

evitar.

El clculo del punto del programa en el que deben insertarse las instrucciones

PREFETCH es muy complicado pues intervienen diversos factores. Por esto, el

ejemplo de arriba es solamente una muestra indicativa de cmo y dnde se podran

insertar estas instrucciones en un fragmento de un programa.



3. Memoria Principal

El siguiente escaln en la memoria del sistema es la memoria principal. Esta

memoria se encarga tanto de proporcionar los datos solicitados por la cach, como de

servir de buffer con los dispositivos de entrada/salida, pues es el destino de los datos

de entrada y fuente de los datos de salida.

Las prestaciones de la memoria principal se suelen medir considerando dos

factores: ancho de banda y latencia.

El ancho de banda es el nmero de bits que se puede transferir en cada

acceso a memoria, es decir, el ancho del bus de datos. Actualmente el tamao comn

del bus de datos es de 64 bits.

La latencia de memoria considera dos medidas: el tiempo de acceso y el

tiempo de ciclo.

El tiempo de acceso es el tiempo mximo que transcurre desde que se realiza

la peticin de L/E por parte del procesador

Arquitectura de Computadoras II · Sin una memoria de la que los procesadores leyeran o escribieran...

Documents

Transcript of Arquitectura de Computadoras II · Sin una memoria de la que los procesadores leyeran o escribieran...