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
Arquitectura de Computadoras II UNPAZ
2 http://campusvirtual.unpaz.edu.ar Profesores: Juan Funes, Walter Salguero, Fabin Palacios
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
Arquitectura de Computadoras II UNPAZ
3 http://campusvirtual.unpaz.edu.ar Profesores: Juan Funes, Walter Salguero, Fabin Palacios
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
Arquitectura de Computadoras II UNPAZ
4 http://campusvirtual.unpaz.edu.ar Profesores: Juan Funes, Walter Salguero, Fabin Palacios
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
Arquitectura de Computadoras II UNPAZ
5 http://campusvirtual.unpaz.edu.ar Profesores: Juan Funes, Walter Salguero, Fabin Palacios
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.
Arquitectura de Computadoras II UNPAZ
6 http://campusvirtual.unpaz.edu.ar Profesores: Juan Funes, Walter Salguero, Fabin Palacios
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.
Arquitectura de Computadoras II UNPAZ
7 http://campusvirtual.unpaz.edu.ar Profesores: Juan Funes, Walter Salguero, Fabin Palacios
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.
Arquitectura de Computadoras II UNPAZ
8 http://campusvirtual.unpaz.edu.ar Profesores: Juan Funes, Walter Salguero, Fabin Palacios
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.
Arquitectura de Computadoras II UNPAZ
9 http://campusvirtual.unpaz.edu.ar Profesores: Juan Funes, Walter Salguero, Fabin Palacios
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).
Arquitectura de Computadoras II UNPAZ
10 http://campusvirtual.unpaz.edu.ar Profesores: Juan Funes, Walter Salguero, Fabin Palacios
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.
Arquitectura de Computadoras II UNPAZ
11 http://campusvirtual.unpaz.edu.ar Profesores: Juan Funes, Walter Salguero, Fabin Palacios
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
Arquitectura de Computadoras II UNPAZ
12 http://campusvirtual.unpaz.edu.ar Profesores: Juan Funes, Walter Salguero, Fabin Palacios
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
Arquitectura de Computadoras II UNPAZ
13 http://campusvirtual.unpaz.edu.ar Profesores: Juan Funes, Walter Salguero, Fabin Palacios
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.
Arquitectura de Computadoras II UNPAZ
14 http://campusvirtual.unpaz.edu.ar Profesores: Juan Funes, Walter Salguero, Fabin Palacios
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
Arquitectura de Computadoras II UNPAZ
15 http://campusvirtual.unpaz.edu.ar Profesores: Juan Funes, Walter Salguero, Fabin Palacios
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.
Arquitectura de Computadoras II UNPAZ
16 http://campusvirtual.unpaz.edu.ar Profesores: Juan Funes, Walter Salguero, Fabin Palacios
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.
Arquitectura de Computadoras II UNPAZ
17 http://campusvirtual.unpaz.edu.ar Profesores: Juan Funes, Walter Salguero, Fabin Palacios
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).
Arquitectura de Computadoras II UNPAZ
18 http://campusvirtual.unpaz.edu.ar Profesores: Juan Funes, Walter Salguero, Fabin Palacios
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.
Arquitectura de Computadoras II UNPAZ
19 http://campusvirtual.unpaz.edu.ar Profesores: Juan Funes, Walter Salguero, Fabin Palacios
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.
Arquitectura de Computadoras II UNPAZ
20 http://campusvirtual.unpaz.edu.ar Profesores: Juan Funes, Walter Salguero, Fabin Palacios
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.
Arquitectura de Computadoras II UNPAZ
21 http://campusvirtual.unpaz.edu.ar Profesores: Juan Funes, Walter Salguero, Fabin Palacios
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
Arquitectura de Computadoras II UNPAZ
22 http://campusvirtual.unpaz.edu.ar Profesores: Juan Funes, Walter Salguero, Fabin Palacios
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.
Arquitectura de Computadoras II UNPAZ
23 http://campusvirtual.unpaz.edu.ar Profesores: Juan Funes, Walter Salguero, Fabin Palacios
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.
Arquitectura de Computadoras II UNPAZ
24 http://campusvirtual.unpaz.edu.ar Profesores: Juan Funes, Walter Salguero, Fabin Palacios
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.
Arquitectura de Computadoras II UNPAZ
25 http://campusvirtual.unpaz.edu.ar Profesores: Juan Funes, Walter Salguero, Fabin Palacios
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.
Arquitectura de Computadoras II UNPAZ
26 http://campusvirtual.unpaz.edu.ar Profesores: Juan Funes, Walter Salguero, Fabin Palacios
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.
Arquitectura de Computadoras II UNPAZ
27 http://campusvirtual.unpaz.edu.ar Profesores: Juan Funes, Walter Salguero, Fabin Palacios
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.
Arquitectura de Computadoras II UNPAZ
28 http://campusvirtual.unpaz.edu.ar Profesores: Juan Funes, Walter Salguero, Fabin Palacios
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.
Arquitectura de Computadoras II UNPAZ
29 http://campusvirtual.unpaz.edu.ar Profesores: Juan Funes, Walter Salguero, Fabin Palacios
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).
Arquitectura de Computadoras II UNPAZ
30 http://campusvirtual.unpaz.edu.ar Profesores: Juan Funes, Walter Salguero, Fabin Palacios
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.
Arquitectura de Computadoras II UNPAZ
31 http://campusvirtual.unpaz.edu.ar Profesores: Juan Funes, Walter Salguero, Fabin Palacios
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.
Arquitectura de Computadoras II UNPAZ
32 http://campusvirtual.unpaz.edu.ar Profesores: Juan Funes, Walter Salguero, Fabin Palacios
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.
Arquitectura de Computadoras II UNPAZ
33 http://campusvirtual.unpaz.edu.ar Profesores: Juan Funes, Walter Salguero, Fabin Palacios
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.
Arquitectura de Computadoras II UNPAZ
34 http://campusvirtual.unpaz.edu.ar Profesores: Juan Funes, Walter Salguero, Fabin Palacios
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.
Arquitectura de Computadoras II UNPAZ
35 http://campusvirtual.unpaz.edu.ar Profesores: Juan Funes, Walter Salguero, Fabin Palacios
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.
Arquitectura de Computadoras II UNPAZ
36 http://campusvirtual.unpaz.edu.ar Profesores: Juan Funes, Walter Salguero, Fabin Palacios
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).
Arquitectura de Computadoras II UNPAZ
37 http://campusvirtual.unpaz.edu.ar Profesores: Juan Funes, Walter Salguero, Fabin Palacios
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.
Arquitectura de Computadoras II UNPAZ
38 http://campusvirtual.unpaz.edu.ar Profesores: Juan Funes, Walter Salguero, Fabin Palacios
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.
Arquitectura de Computadoras II UNPAZ
39 http://campusvirtual.unpaz.edu.ar Profesores: Juan Funes, Walter Salguero, Fabin Palacios
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.
Arquitectura de Computadoras II UNPAZ
40 http://campusvirtual.unpaz.edu.ar Profesores: Juan Funes, Walter Salguero, Fabin Palacios
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.
Arquitectura de Computadoras II UNPAZ
41 http://campusvirtual.unpaz.edu.ar Profesores: Juan Funes, Walter Salguero, Fabin Palacios
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.
Arquitectura de Computadoras II UNPAZ
42 http://campusvirtual.unpaz.edu.ar Profesores: Juan Funes, Walter Salguero, Fabin Palacios
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