7 memoria cache

En esta asignatura hemos estado viendo cómo mejorar las prestaciones de un ordenador
convencional.
Hasta ahora hemos estado tratando diversas vías para aumentar el ritmo de ejecución de
instrucciones en la CPU. Ahora vamos a ocuparnos de cómo mejorar el tiempo de acceso a los
datos que están en memoria principal. Para ello incorporaremos la memoria caché, un nuevo
nivel en la jerarquía de memorias situado entre la CPU y la memoria principal.
Veremos cómo una memoria tan pequeña (en comparación con la memoria principal) puede ser
tan útil, y las maneras en que se puede organizar para aprovecharla de la mejor manera posible.
La Memoria - 1Arquitectura de Computadores

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
información, no habría ordenadores digitales de programa almacenado (como son todos los
actuales desde el EDVAC en 1945).
Por una parte tenemos que la velocidad de ejecución 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,
también es importante disponer de una gran cantidad de memoria, para facilitar la ejecución de
programas que son grandes o que trabajan con una gran cantidad de datos.
Por esto, idealmente, la memoria debería ser rápida, grande y barata. Como cabría esperar, hay
un compromiso entre estas tres características 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 diseñador de la arquitectura de un ordenar le gustaría disponer de una tecnología de memoria que le proporcionara
una gran capacidad, tanto porque le ofrece una gran cantidad de memoria, como porque el coste por bit es pequeño.
Sin embargo, para conseguir buen rendimiento y velocidad se necesitan memorias de rápido acceso, que son de poca
capacidad y más caras.
La pirámide del gráfico 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 solución 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 más a los datos del programa en
ejecución que a los de uno que no se ejecuta desde hace un año; y de igual manera, en un momento dado se accede
más a los datos de una expresión que se está evaluando en ese preciso instante que a otros datos del programa.
En lugar de decidirnos por un único tipo o tecnología de memoria, lo que hay que hacer es construir una estructura
con una jerarquía de memoria en la que haya diversas tecnologías, de tal manera que los pocos datos con los que
se está ejecutando la instrucción en curso están en los registros de la CPU; los datos de las últimas instrucciones, en
la memoria caché; el resto de los datos del programa en ejecución estarán repartidos entre memoria principal y
secundaria de rápido acceso (discos magnéticos); los programas o datos que no se ejecutan asiduamente se guardan
en memoria secundaria rápida y en memorias secundarias masivas de mayor tiempo de acceso, como la cinta
magnética y el disco óptico.
La CPU y el sistema operativo se encargarán de ir llevando y trayendo los datos de las memorias lentas a las rápidas
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 jerarquía de memoria.
El procesador dispone de unos registros cuyo tamaño puede ir desde unos pocos octetos a unos
kilobytes de memoria; su tiempo de acceso está alrededor de 250 ps.
La memoria caché, actualmente, tiene una capacidad que puede ir de unos 64 KB hasta más de
un megabyte. En cuanto a su tiempo de acceso, está alrededor de 1 ns.
La capacidad de la memoria principal es del orden de gigabytes, mientras que su tiempo de
acceso está por debajo de los 100 ns.
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, según se desciende en la jerarquía de memoria hacia los
dispositivos de almacenamiento masivo, la capacidad va aumentando en un factor de 1000, pero
el tiempo de acceso también lo hace, según un factor de 100.
Los discos de estado sólido (SSD) tienen un tiempo de acceso de alrededor de una décima 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.

La caché es una pequeña memoria situada entre el procesador y la memoria principal, que
aunque muy rápida, 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 continuación.
El Principio de Localidad de Referencia dice que los accesos a memoria que realiza la CPU no
están 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 están contenidos en una o varias
secciones de memoria contigua, por lo que los accesos a la memoria se concentran en las áreas
donde están las instrucciones o los datos del programa en ejecución.
El análisis de los programas muestra que la mayoría del tiempo de ejecución 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 porción de tiempo dada, se
concentran, concretamente, no en todo el programa que se está ejecutando, sino, más
específicamente, en el fragmento del bucle que en ese momento se está ejecutando.
Según esto, si el segmento activo de un programa se puede ubicar en una memoria rápida,
aunque pequeña, el tiempo total de ejecución puede verse drásticamente 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 página anterior, una
instrucción que se acaba de ejecutar recientemente es muy probable que se vuelva a ejecutar en
un futuro muy próximo. Ahora, la secuencia detallada de la ejecución 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
instrucción recientemente ejecutada (en cuanto a sus direcciones en memoria) también es muy
probable que se ejecuten muy pronto. A los datos u operandos de un programa les sucede lo
mismo, no están dispersos por toda la memoria, sino que están 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 información que contenga dicho byte y unos pocos más que estén 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 tamaño de un bloque suele ser el ancho del bus de datos o un múltiplo de él, es decir, 2, 4, 8,
… bytes.

Conceptualmente el funcionamiento de una memoria caché es muy simple. La circuitería de
control de la memoria está diseñada 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 rápidamente.
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 cachés, se emplea el término 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
línea.
Como se muestra en la figura, cuando se recibe una petición de lectura de la CPU, el contenido
del bloque completo de memoria principal que contiene la dirección 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 dirección a la
memoria caché y ésta comprueba si tiene el dato correspondiente a esa dirección. 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 fácil que en las próximas lecturas se haga referencia a otras
palabras cercanas a esa palabra.

Como se muestra en la figura, cuando se recibe una petición de lectura de la CPU, el contenido del bloque completo
de memoria principal que contiene la dirección 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 número de bloques de memoria que es muy pequeño
comparado con el número 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 “función de correspondencia”. La función de
correspondencia a utilizar se establece mediante la política de ubicación. Cuando la caché está llena, y se
referencia una dirección 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 decisión se denominan algoritmos o políticas de sustitución.
Obsérvese que la CPU no necesita conocer explícitamente la existencia de la caché, sino que genera una petición de
lectura o escritura utilizando direcciones de memoria principal, y la circuitería 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
operación de lectura o escritura se realiza sobre la dirección correspondiente en la caché, y si la operación es de
lectura, la memoria principal no se ve implicada en la ejecución. Si la operación es una escritura, la palabra afectada
en la memoria caché deberá actualizarse, en algún momento, en la memoria principal, para que el contenido de un
bloque en la caché sea idéntico al de su correspondiente en memoria principal. En estos casos, la actualización en
memoria principal de los bloques modificados en la caché se realiza según una política de escritura o de
actualización.
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
continuación, la palabra solicitada se envía a la CPU. Otra opción consiste en enviarle la palabra directamente de la
memoria principal a la CPU y al mismo tiempo cargarla en la caché. Esta última técnica, denominada “carga
directa” (load through), aunque reduce el tiempo de espera de la CPU, requiere un hardware más complejo.
Más adelante, al comentar las políticas de escritura, veremos las opciones a tomar cuando se produce una falta de
caché en una operación de escritura.
En la operación de la caché se nos plantean, por tanto, estas tres preguntas:
P1: ¿Dónde situar un bloque en la caché? (Política de ubicación).
P2: ¿Qué bloque reemplazar ante una caché llena? (Política de sustitución).
P3: ¿Qué hacer ante una operación de escritura? (Política de actualización).

Sabemos que la memoria principal está formada por un máximo de 2n celdas direccionables, cada
una con una única dirección 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 número de
entradas de la caché es mucho menor que el número 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 más bloques de memoria que entradas o “líneas” 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 línea. Como veremos, esta etiqueta suele estar formada por los bits más significativos
de la dirección del bloque en memoria principal..
Cada entrada de la caché también debe disponer de un bit V que indique si esa entrada está
ocupada por algún bloque (entrada válida) o todavía no se ha cargado con ningún bloque desde
que se arrancó la máquina. Este bit se pone a cero en la inicialización de la caché, y se activa
cuando se trae un bloque a la línea 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é también dispone de un bit de ensuciado, que al estar activo
indica que el bloque ha sido modificado desde que se trajo de memoria principal.

Ya que hay menos entradas o líneas de caché que bloques en memoria principal, se nos plantea
un problema cuando traemos un bloque de memoria a la caché: ¿Dónde 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 dónde podría estar ubicado este bloque.
Este problema se resuelve según una política de ubicación. Cada política de ubicación utiliza
una función de correspondencia entre las direcciones de los bloques en memoria principal y sus
direcciones en la caché. Así, diremos que las diferentes políticas de ubicación 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 continuación vamos a tratar con cierto detalle cada una de estas funciones de correspondencia.
Para cada una de ellas veremos su estructura general acompañada de un ejemplo, que en los tres
casos supondrá lo siguiente:
1. El tamaño 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 líneas 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.

La función más sencilla de correspondencia es la conocida como correspondencia directa,
según la cual cada bloque de memoria principal solamente puede ubicarse en una única línea de
la caché. La línea que le corresponde a cada bloque se obtiene mediante este algoritmo:
Línea_caché = Número_de_bloque módulo Líneas_en_la caché
En la tabla de arriba pueden verse los bloques de memoria principal que pueden ubicarse en cada
línea de la caché si son referenciados por la CPU.

Este algoritmo se implementa fácilmente a partir de las direcciones que genera la CPU. En lo que concierne a la
caché, cada dirección 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 dirección indican uno de los 2b bloques de memoria principal. Como todos los bloques
de memoria principal no caben en las L líneas de la caché, ésta interpreta estos b bits como una composición de
dos campos: la línea y la etiqueta.
Línea: Este campo indica la línea 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 dirección, e indica una de las L líneas de la
caché, pues 2l = L.
Pero claro, va a haber muchos bloques a los que les corresponda la misma línea de caché. Concretamente, los
restantes b-l bits, los de mayor peso de la dirección, indican a cuántos bloques les corresponde la misma línea en
la caché.
En la figura de la diapositiva anterior se puede ver que en una caché con L líneas, a la línea 0 le corresponden los
bloques número 0, L, 2L, 3L, ...; a la línea 1 le corresponden los bloques 1, L+1, 2L+1, 3L+1, ...; y a la línea 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 línea son los b-l bits de
mayor peso, esto es, el campo de “etiqueta”. Obsérvese que aunque una línea de caché puede corresponder a
varios bloques, todos esos bloques tendrán una etiqueta distinta.
Cuando la CPU realiza una lectura, la dirección se divide en estos tres campos. Tomando los b bits del campo de
bloque se obtiene el número de bloque de memoria principal. Con el algoritmo arriba indicado se obtiene la línea que
le corresponde al bloque. Si la línea no está ocupada, se trae el bloque desde memoria principal a esa línea, y con el
desplazamiento que indican los d bits de menor peso de la dirección se obtiene la celda dentro del bloque. Los b-l bits
de mayor peso de la dirección deben ponerse en el campo de etiqueta de la línea 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 dirección
que se está referenciando. Para ello simplemente hay que comprobar que el campo de etiqueta de la dirección es
igual a la etiqueta de la línea que corresponde a ese bloque. Si no es así, habrá que traer el bloque de memoria y
sustituir al que estaba en esa línea. Esto puede representar un problema.

Veamos un ejemplo de ubicación mediante correspondencia directa. Para ello, supondremos los
siguientes valores:
1. El tamaño 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 líneas 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 más peso de la dirección; los dos bits de menor peso constituyen el
desplazamiento de la palabra dentro del bloque. En la caché, por su parte, el número de línea se
expresa mediante 10 bits. La ejecución del algoritmo de la función de correspondencia para
averiguar la línea que le corresponde a un bloque de memoria (dividir un número 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 número de bloque.
En la parte inferior de la transparencia podemos ver las correspondencias entre bloques y líneas
para este ejemplo.

Las direcciones de memoria están descompuestas en número de bloque y desplazamiento. El
número de bloque lo mostramos dividido en dos campos, para ver claramente la etiqueta de cada
bloque y la línea que le corresponde.
Así, podemos ver cómo al bloque 0 le corresponde la línea 0; al bloque 1, la línea 1; y en último
lugar, al bloque 3FFF le corresponde la última línea, la 3FF.
Como ya sabíamos, al bloque 400 H, también le corresponde la línea 0, pero como se puede
apreciar, el contenido de esta línea es el del bloque 0, y es razonable, puesto que la etiqueta de la
línea 0 es la correspondiente al bloque 0, y no la del bloque 400 H, que tiene una etiqueta 0001.
La técnica de la correspondencia directa es simple y económica, pues la ubicación se obtiene
directamente a partir del algoritmo de la función de correspondencia.
Sin embargo, el problema que presenta la correspondencia directa son las colisiones; es decir,
que a cada línea de caché (donde sólo 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 línea de la caché, los dos bloques estarán continuamente expulsándose de
la caché, con lo que la tasa de aciertos descenderá drásticamente aún cuando la caché no esté
completamente ocupada.

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 línea de la caché, por lo que mientras la memoria caché no esté llena, no habrá que
hacer ninguna sustitución. Cuando esté llena y haya que traer un nuevo bloque, habrá que
sustituir alguno de los bloques según la política de sustitución más apropiada, es decir, la que
genere menos faltas de caché.

Con la correspondencia asociativa, la caché ve cada dirección de memoria formada solamente por
dos campos: el desplazamiento dentro del bloque (los bits menos significativos) y el número de
bloque o etiqueta (los más significativos). Ahora cada bloque de memoria principal tiene una única
etiqueta posible, que es precisamente el número de bloque.
Así, para saber si un bloque está en la caché, su lógica de control debe comparar la etiqueta de la
dirección generada por la CPU con todas las etiquetas de la caché. Para que estas
comparaciones puedan realizarse rápidamente, cada entrada de la caché cuenta con un
comparador, de tal manera que las comparaciones de la etiqueta de la dirección de memoria con
todas las etiquetas de las líneas 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 línea de la caché, y su
espacio se puede aprovechar más 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
líneas estén ocupadas. Con esta técnica ya no deben producirse las repetidas expulsiones mutuas
de dos bloques que teníamos con la correspondencia directa. Los algoritmos de sustitución que
veremos más adelante se diseñarán precisamente para mejorar lo más posible la tasa de aciertos.
La desventaja obvia de la correspondencia asociativa es el incremento económico que genera la
electrónica adicional necesaria.

En esta transparencia mostramos la aplicación de la función de correspondencia asociativa a la
arquitectura del ejemplo que estamos utilizando para ilustrar las políticas de ubicación.
Como vemos, la dirección de 16 bits ahora solamente se descompone en dos campos: el
desplazamiento, que tiene que seguir siendo de 2 bits, pues lo impone el tamaño del bloque; y el
número de bloque, de 14 bits, que se utiliza como etiqueta.

Como hemos dicho, la dirección de 16 bits ahora solamente se descompone en dos campos: el
desplazamiento, que tiene que seguir siendo de 2 bits, pues lo impone el tamaño del bloque; y el
número de bloque, de 14 bits, que se utiliza como etiqueta.
Esto quiere decir que en cada línea de la caché, junto con cada bloque de 4 bytes deben
almacenarse también los 14 bits de su etiqueta correspondiente.
Ya que esta correspondencia no fuerza ninguna ubicación 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 recién traído. Puesto que no se fija de antemano cuál debe ser el bloque a
sustituir, no se corre el peligro de la correspondencia directa, en la que podía darse el caso de
tener que sustituir un bloque que se estaba referenciando muy a menudo. La política de
sustitución 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é.

La correspondencia asociativa de conjuntos combina la economía de la correspondencia
directa con la tasa de aciertos de la correspondencia asociativa. Consiste en agrupar las líneas de
la caché en conjuntos, de tal forma que la función de correspondencia permita que un bloque de la
memoria principal pueda ubicarse en cualquier línea de un conjunto concreto.
Con esta política, la memoria caché se divide en C conjuntos de L líneas cada uno. Así, el número
M de líneas 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 módulo C
Una vez averiguado el conjunto c de la caché que le corresponde al bloque b, éste puede ubicarse
en cualquiera de las líneas del conjunto c.

También de manera equivalente a la correspondencia directa, cuando la CPU suministra una
dirección para acceder a la memoria principal, la dirección 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
operación número módulo 2n es lo mismo que tomar los n bits de menor peso del número, 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.
Obsérvese que si el número de líneas por conjunto se lleva a los casos extremos, se da lugar a
las otras dos correspondencias que hemos visto. Cuando el número de líneas 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 líneas de la caché, se trata de una correspondencia
completamente asociativa.
Normalmente se suelen utilizar 2 líneas por conjunto (memoria asociativa de dos vías), lo cual
mejora notablemente la tasa de aciertos de la correspondencia directa. A medida que se aumenta
el número de líneas por conjunto, aumenta el coste de la memoria pero sin conseguir una mejora
significativa.
Con esta técnica se disminuye mucho el coste de la electrónica adicional de la correspondencia
asociativa, pues mientras que en ésta se requieren tantos comparadores como líneas, en la
asociativa de conjunto de dos vías, solamente son necesarios dos comparadores.

Veamos ahora cómo aplicar la correspondencia asociativa de conjuntos a nuestro ejemplo tipo.
Ahora la dirección 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 número de bloque, queda indicado por los 14 bits de mayor peso, aunque
en este caso, para conocer la ubicación de cada bloque en la caché solamente necesitamos los 8
bits de menor peso del número de bloque, que es el resultado de la operación Num_Bloque
módulo Num_Conjuntos. Así, tenemos que los bloques con número 0, 100H, 200H, etc., deben
ubicarse en el conjunto 0 de la caché; los que tienen número 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 podía haber un bloque en una dirección, ahora tenemos que
en una misma dirección de la caché puede haber tantos bloques como permita el tamaño del
conjunto. En nuestro ejemplo los conjuntos son de 4 bloques, como el Motorola 68040 y el
PowerPC 604, que también utilizan una memoria asociativa con conjuntos de 4 bloques (memoria
asociativa de conjuntos de 4 vías). Los Pentium, sin embargo, disponen de una caché asociativa
de conjuntos de 2 vías.
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 sabíamos,
nos encontramos con que al bloque 100H también le corresponde el conjunto 0, pero en esta
ocasión, para cargar el bloque 100H no hay que expulsar al bloque 0 (como sucedía en la
correspondencia directa), ya que ahora en cada conjunto se pueden ubicar hasta 4 de los bloques
a los que la función de correspondencia otorga la misma dirección. 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 podían estar expulsándose mutuamente, desaprovechando así
la eficacia de la memoria caché.

Cuando se produce una falta de caché y hay que traer el bloque desde memoria principal, si no hay una línea
libre para el bloque, habrá que sustituir alguno de los que están en la caché por el recién referenciado.
Si se utiliza correspondencia directa, no hay ninguna elección, hay que sustituir el bloque de la única línea 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 función de
correspondencia es la completamente asociativa, se puede elegir para sustituir cualquiera de los bloques que
están en la caché. Así, tenemos que en los dos últimos tipos de correspondencias necesitamos una política de
sustitución. Esta cuestión es extremadamente importante, pues la política utilizada es un factor determinante
para la tasa de aciertos del sistema.
Hay dos enfoques a la hora de elegir una política de sustitución: el que tiene en cuenta la estadística de
utilización de los bloques (la historia de uso), y el que no lo tiene en cuenta. Entre los primeros se encuentran las
políticas LRU y LFU, y como representantes del segundo enfoque está la política random y la FIFO.
LRU (Least Recently Used). En general, el objetivo es mantener en la caché los bloques que tienen más
probabilidades de ser accedidos en un futuro próximo, pero no resulta nada fácil 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 próximo. Por eso, cuando hay que seleccionar un bloque víctima, parece razonable elegir
el que lleva más tiempo sin ser referenciado (el menos recientemente referenciado, the least recently used).
Para implementar este sistema se requiere añadir un contador a cada línea de la caché, de tal manera que cada
vez que se referencia un bloque su contador se pone a cero, y los de los demás (del conjunto o de toda la
memoria) se incrementan en uno. Cuando se trae un nuevo bloque, se elige como víctima el que tiene el
contador más alto, y al nuevo bloque se le pone el contador a cero.
Esta política de sustitución falla cuando se está accediendo de forma secuencial y cíclica a elementos de una
matriz que no cabe completamente en la caché.
Una política parecida es la LFU (Least Frequently Used), en la cual se sustituye el bloque menos referenciado.
Ésta también se implementa con ayuda de contadores.
Como políticas no basadas en la estadística de uso, tenemos la FIFO (First In, First Out) que ofrece unos
resultados ligeramente inferiores a la LRU, y que se implementa con ayuda de un buffer circular. 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 cuáles han sido las últimas referencias; por esto también puede fallar con algunas matrices.
La política Random, que elige al azar el bloque a sustituir, ofrece una buena tasa de aciertos, no tiene el
problema de la LRU con las matrices, y es fácil y económico de implementar.

El problema de la coherencia de cachés tiene que ver con la política de actualización.
Aquí hay dos situaciones a considerar. En un ordenador puede haber más de un elemento que
acceda a la memoria principal, pues en un ordenador actual no es raro encontrarnos con varias
CPU’s o, simplemente, los dispositivos de entrada/salida gobernados directamente desde alguna
CPU o a través del controlador de DMA. Según 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. También 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 cachés.

El problema de coherencia de las cachés depende de la política de escritura o
actualización que se utilice.
La técnica más simple es la escritura o copia inmediata (write through), según 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 tráfico que genera en los buses del sistema. Podría pensarse que también supone
una sobrecarga de tiempo, puesto que además de escribir en la caché, hay que escribir
también en la memoria principal, pero está última operación puede realizarse en paralelo
con la escritura en memoria caché o con otras actividades por lo que, en la práctica, no
supone un tiempo adicional.
La otra alternativa es la escritura o copia diferida (copy back), en la cual una operación
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 línea, 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
línea de la caché con el nuevo bloque. El problema que tiene es que, en un momento
dado, hay datos en memoria principal que no están actualizados, lo cual puede originar
problemas de coherencia de datos.

Además de las cuestiones generales que hemos tratado, hay otras consideraciones que se deben
tener en cuenta en el diseño de una memoria caché: el tamaño total de la memoria caché y el
tamaño de cada bloque.
Tamaño de la caché. Ya hemos comentado que nos gustaría que el tamaño de la caché fuera lo
suficientemente pequeño como para que el coste medio por bit de memoria total (caché más
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 más grande sea la caché, mayor es el número de puertas necesarias para su
direccionamiento, por lo que las grandes cachés tienden a ser ligeramente más lentas que las
pequeñas.
Por el principio de localidad temporal, a mayor número de líneas 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 número de líneas, no se mejorará la
tasa de aciertos.
No se puede establecer y fijar un tamaño óptimo de la caché, pues las prestaciones de la caché
dependen mucho de las características de los programas en ejecución y, desde luego, del estado
de la tecnología.
Hoy día (año 2015), el procesador Intel Core I7 5960-X Haswell, con 8 núcleos, tiene 64+64 KB de
caché de nivel 1 por núcleo; 256 KB de caché L2 por núcleo, y 20 MB de caché L3 compartida
entre todos los núcleos. Los modelos Xeon (hasta 18 núcleos) tienen hasta 45 MB de caché L3.

En la tabla superior se muestra el tamaño de la caché de algunos procesadores populares de
propósito general.
Téngase 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 número de núcleos y, por
supuesto, con diversas opciones de cantidad de memoria caché. No obstante, lo presentado aquí
puede dar una idea de la evolución que ha ido teniendo el tamaño de la memoria caché.
Los procesadores de hoy día suelen tener una memoria caché organizada en tres niveles. En el
nivel 1, cada núcleo 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) también es independiente para cada núcleo, 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 núcleos del procesador.

Tamaño de bloque. Cuando se trae un bloque a la caché no solo se trae la palabra referenciada,
sino también unas cuantas adyacentes. Así, debido al principio de localidad espacial, a medida
que el tamaño del bloque aumenta, también aumenta la probabilidad de acierto. Sin embargo, esta
probabilidad empezará a disminuir si el tamaño 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
información que hay que reemplazar al traer un bloque grande a la caché.
Estas son las consecuencias negativas de los bloques de gran tamaño:
1. Al ser los bloques más grandes, se reduce el número 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 después de haberse cargado, lo cual, según el principio de localidad, no
es nada bueno.
2. A medida que el tamaño del bloque se hace mayor, cada palabra adicional está más alejada
de la que se ha referenciado, por lo que tiene menor probabilidad de ser requerida en un
futuro próximo.
3.  Cuando se trae un bloque a la caché desde la memoria principal, cuanto mayor sea el
bloque, más tiempo se tarda en leerlo.
Hoy día, el tamaño 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 número de fallos en los accesos, dividido por el número total de
accesos.
La causas de los fallos de caché se pueden clasificar en estas tres categorías:
• 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 tamaño de la caché (incluso aunque fuera infinita).
• Por capacidad: Si la caché no puede contener todos los bloques necesarios para la ejecución
de un programa se producen fallos, porque algunos bloques serán expulsados y más tarde
volverán a ser referenciados y recuperados.
• Por conflicto: Si la política de ubicación no es completamente asociativa (correspondencia
directa o de conjuntos), habrá fallos desafortunados, pues aún habiendo líneas libres en la
caché, se pueden producir colisiones, es decir, que al traer un bloque a la caché se le asigna la
línea de otro bloque que ya estaba en la caché, con lo que este último será expulsado, y más
tarde puede que vuelva a ser referenciado (con el consiguiente fallo de caché).
En las siguientes páginas 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 diseño de una
caché para mejorar la tasa de fallos. En las siguientes páginas se abordarán otras mejoras de
diseño más avanzado.
La manera más simple de reducir la tasa de fallos es aumentar el tamaño del bloque para
aprovechar el principio de localidad espacial. Con bloques más 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 tamaño
de la caché. No obstante, debe tenerse en cuenta que a medida que aumenta la capacidad de
una memoria, también aumenta su tiempo de acceso, así como el coste y el consumo.
Cuanto más asociativa sea una memoria (totalmente asociativa o asociativa de conjuntos) menor
será su tasa de fallos por conflictos (colisiones en la ubicación). No obstante, las memoria
asociativas también tienen una mayor penalización en el tiempo de acceso (en los aciertos), y su
precio es más elevado.
Es difícil decidir si se mejora el tiempo de acceso a la caché para seguir el ritmo de los
procesadores con un reloj cada vez más rápido, o disponer de una caché mayor para evitar los
accesos a memoria principal. La solución a esta disyuntiva consiste en tener dos niveles de
caché. La caché de primer nivel (L1) puede ser suficientemente pequeña como para mantener
una buena velocidad, mientras que la de segundo nivel (L2) puede ser suficientemente grande
como para evitar muchos accesos que tendrían que ir a memoria principal. Así, en la caché de
nivel 2, se tiende a una mayor capacidad, bloques grandes y muy asociativa (más vías).

En las siguientes páginas vamos a tratar algunas vías más 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 penalización por fallo. Para los procesadores
superescalares de hoy día, debemos añadir un factor más: el ancho de banda.
Así pues, vamos a organizar las mejoras en las siguientes categorías:
• Reducir el tiempo de acceso (en acierto), mediante cachés pequeñas y simples, predicción de
la vía (para cachés asociativas de conjuntos) y cachés de trazas.
• Reducir la penalización por fallo mediante la técnicas de “la palabra crítica, primero”, así
como aumentando el paralelismo: prealimentación por hardware y en compilación.
• Reducir la tasa de fallos, con ayuda de optimizaciones en el compilador.
• Incrementar el ancho de banda mediante cachés segmentadas, multibanco y no bloqueantes.

Como se puede apreciar en el gráfico de arriba, el tiempo de acceso a las memorias caché crece a medida
que aumenta su tamaño, especialmente a partir de los 256 KBytes. Como vemos, también es mayor el
tiempo de acceso para las memorias de correspondencia asociativa de conjuntos (2, 4 y 8 vías) que para
las de simple correspondencia directa (una vía).
Por una parte, es que “el hardware más pequeño es más rápido”, es decir, una memoria de menor
capacidad requiere menos circuitos para el cálculo de direcciones, con lo que acaba siendo más rápida.
Por otra parte, tenemos que una gran parte del tiempo de acceso a una caché se debe al tiempo empleado
en la comprobación de si el bloque referenciado está en la memoria caché, es decir, en la comparación de
la parte de etiqueta de la dirección referenciada con la correspondiente etiqueta de las líneas de la caché.
Por esto, cuanto más simple sea la política de ubicación, menor tiempo se requerirá para la comprobación.
La correspondencia directa es la más sencilla y, además, se puede solapar en el tiempo la comprobación
de la etiqueta con el envío del bloque; en caso de fallo, se desecha el bloque.
No obstante, una caché pequeña también 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 tamaño de
esta caché L2 deberá ser lo suficientemente pequeño como para que pueda mantenerse dentro del mismo
chip del procesador, para mantener así la máxima velocidad en el acceso.
Aunque la capacidad de la caché del chip del procesador (on-chip caché) ha ido aumentando
progresivamente, el tamaño 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 cálculo 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 más simple y, por lo tanto, más rápida, aunque
también sabemos que la correspondencia asociativa (o la de conjuntos) aprovecha más la
capacidad de la caché, no expulsa bloques cuando hay líneas libres.
Con esta mejora (predicción de la vía) 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 cuál es la vía de la caché en la que está el bloque buscado. La comparación 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 predicción acierta, la latencia de acceso será la más rápida posible; si la
predicción falla, será necesario otro ciclo de reloj para comprobar la etiqueta de otro de los
bloques.
Para la implementación de este mecanismo se le añaden unos bits de predicción a cada bloque
de la caché. Cuando se acierta en una predicción, 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 continuación se cambian convenientemente los valores de los bits de predicción.
Según las simulaciones, la predicción de la vía tiene una tasa de acierto de alrededor del 85%
para una caché de dos vías, es decir, que ahorra ciclos de reloj en el 85% de los accesos a
memoria.

Cachés compartidas o separadas.
Los diseños de los primeros sistemas que incluyeron memoria caché disponían de una única
caché para almacenar tanto operandos como instrucciones.
Hay dos ventajas potenciales en mantener la caché unificada:
1. Para un tamaño de caché dado, la versión unificada ofrece una mayor tasa de aciertos que la
dividida, ya que se establece automáticamente el equilibrio necesario entre el espacio utilizado
para las instrucciones y para los datos (operandos). Es decir, que si, por ejemplo, un modelo
de ejecución tiende a realizar más referencias a instrucciones que a datos, la caché tenderá a
llenarse con más instrucciones que con datos.
2. Es mucho más simple de diseñar e implementar una caché compartida.
A pesar de estas ventajas, los potentes procesadores segmentados de hoy día tienden a utilizar
cachés 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 ejecución segmentada de las instrucciones (pipeline), con cachés separadas se
permite el acceso simultáneo, pues se puede acceder a un dato al mismo tiempo que la unidad de
prefetching extrae la siguiente instrucción.

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 podía realizar
en un solo ciclo de reloj, ahora requiere varios ciclos, con lo que la duración de una instrucción
ahora requiere más ciclos de reloj para completarse.
Para mejorar esta situación, lo que se puede hacer es segmentar loa accesos a la memoria caché
tal como se muestra en el gráfico, 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 ejecución 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 después de un fallo.
Una caché no bloqueante permite que se continúen devolviendo datos de accesos con acierto,
mientras se espera a que se consiga el dato que provocó un fallo.
Esta mejora reduce la penalización por fallo, pues, ante un fallo, continúa aceptando peticiones del
procesador en lugar ignorarlas hasta que se resuelva el fallo.
Una mejora adicional, aunque compleja, consiste en permitir múltiples fallos solapados, es decir
que ante un fallo, al atender otra petición del procesador, se puede producir un fallo más y, aún
así, seguir aceptando peticiones del procesador.
En general, los procesadores “fuera de orden” son capaces de camuflar la mayoría de los fallos de
las cachés L1 que consiguen acierto en la de nivel 2, pero no son capaces hacerlo con la mayoría
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 múltiples y simultáneos.
En una memoria de múltiples bancos, cada banco tiene asignado un rango de direcciones de
memoria.
Una memoria de n bancos permite n accesos simultáneos a la memoria, siempre que las
direcciones pertenezcan a bancos distintos.
En las cachés, en lugar de tratar cada caché como un bloque monolítico, se puede dividir en
bancos independientes que soporten múltiples accesos simultáneos.
Las memorias multibanco trabajan mejor cuando los accesos están distribuidos entre los bancos.
Una distribución de las líneas de la caché, que funciona bien, consiste en distribuir las direcciones
de manera secuencial y alterna. En el ejemplo de arriba se muestra la distribución 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 cachés.
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 debería tener más bancos que
el número máximo de accesos simultáneos que pueda requerir por parte del procesador.

Las cachés de actualización 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 jerarquía de
memoria (caché L2 o memoria principal).
Cuando se ejecuta una instrucción store, si el buffer de escritura tiene una entrada libre, el dato
junto con su dirección se escriben en el buffer y, desde el punto de vista del procesador, la
escritura ha finalizado. A partir de ahí, mientras el procesador continúa 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 tamaño del buffer suele ser de 4 entradas, y se gestiona mediante una política 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 también con las memorias de escritura diferida (write-back).
Veamos este aspecto en la siguiente página.

En una caché [de escritura o actualización diferida (write-back)], cuando se debe hacer una
sustitución de bloque, al bloque expulsado se le conoce como víctima. Esta víctima 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 cachés de escritura diferida, al buffer de
escritura se le conoce como buffer de víctimas o caché de víctimas.
La caché de víctimas, por tanto, contiene los bloques que se han expulsado de la caché ante un
fallo y una falta de línea libre, que fuerza una sustitución.
En las cachés de escritura diferida, los bloques que por una sustitución son expulsados y no han
sido modificados (están “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 víctimas, todos
los bloques expulsados se meten en la caché de víctimas, pues ante una fallo de caché L1, se
comprueba el contenido del buffer de víctimas para ver si el bloque deseado todavía se encuentra
en dicho buffer. En caso afirmativo, se toma el bloque del buffer, evitando así la petición del dato a
la caché L2 o a memoria principal.
El propósito 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 víctimas es reducir el impacto de las sustituciones de bloques.
Hoy día, los buffers de escritura son bastante más populares que las cachés de víctimas.

Ya hemos visto los beneficios del buffer de escritura y del buffer de víctimas. Vamos a continuar
sacando provecho de él.
Cuando el procesador arranca una escritura en memoria, se comprueba si la dirección 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 más datos que pertenezcan al mismo bloque, se pueden
refundir en una única operación de escritura en memoria, la escritura del bloque. Sin write
merging, cada escritura de un dato generaría su correspondiente escritura en memoria (de
bloques completos).
Visto el concepto, write merging podría traducirse por “fusión 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 también
reduce las paradas del procesador, pues aprovecha más las escrituras, ya que cada bloque que
se escribe contiene más datos modificados, pues cuando no hay write merging, cada petición de
escritura del procesador (de un dato simple) genera la ocupación de una entrada completa (para
un bloque completo) en el buffer de escritura.

Esta mejora para reducir la penalización ante un fallo de caché está basada en la observación de
que, normalmente, el procesador realiza lecturas de un byte o una palabra, no de un bloque
completo. Así, la estrategia de esta optimización 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 ejecución mientras, en paralelo, se carga el bloque completo en la caché.
Para hacer esto hay dos estrategias:
• La palabra crítica, primero. Ante un fallo de caché, se carga primero la palabra solicitada y se
le envía al procesador. El procesador continúa la ejecución 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 rápido. 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 envía para que prosiga la ejecución mientras se carga el resto del bloque en la caché.
Generalmente, estas técnicas solo son eficaces en diseños en cachés con bloques grandes, pues
la diferencia entre cargar una palabra o el bloque completo, es menor cuanto más pequeño sea el
bloque (hasta que el tamaño del bloque es igual al del bus de datos).
También debemos recordar que en las cachés 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
ejecución si ésta es “fuera de orden”.

Las técnicas 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 disposición del código y los datos, de tal manera que
se minimicen las faltas de caché.
Veamos tres ejemplos de cómo se puede reorganizar el código sin afectar a la semántica del
programa.
• Se puede hacer que cada rutina del programa se ubique al comienzo de un bloque, con lo
que, si el código es secuencial, disminuye la posibilidad de un fallo en la caché de código.
• Otra mejora consiste en que si el compilador sabe qué rama de una bifurcación va a ser la más
tomada, puede cambiar el sentido de la bifurcación (y sus respectivos bloques de código) de
tal manera que el bloque de la rama más tomada esté ubicado en secuencia, para no tener que
saltar a otro punto de la memoria, lo que originaría seguramente un fallo de caché.
• El cálculo con matrices es la causa de una gran parte de los fallos de caché. Los datos de una
matriz están 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 están 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 haría a
elementos muy separados en el espacio, con la consecuente mayor probabilidad de fallo.

Otra forma de reducir la penalización 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 más rápido
que la memoria principal.
La pre-alimentación 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 petición a memoria; si no está
en el buffer, se carga ese bloque y el siguiente como se ha indicado antes.
El mecanismo de pre-alimentación 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 ejecución con la pre-carga de datos,
de tal manera que cuando el procesador realice un acceso a esos datos, ya estén cargados en
caché, evitando así el fallo de caché.
Este prefetch software solo tiene sentido si el procesador puede continuar la ejecución al mismo
tiempo que se está pre-cargando datos, es decir, que las cachés no se bloquean durante la
precarga, y continúan 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 emisión 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 código que más se prestan a obtener beneficios de las pre-
cargas.
Arriba a la izquierda tenemos un fragmento de código en el que se realiza un cierto cálculo con los
elementos de una matriz. El compilador, al analizar el código calculará los puntos en los que debe
insertar instrucciones PREFETCH para forzar la pre-carga de datos que utilizará en un futuro
próximo.
El tiempo necesario para la pre-carga debe calcularse bien pues, de lo contrario, un bloque
cargado con demasiada antelación, podría resultar expulsado antes de acceder a él, si se produce
una colisión con otro bloque que sea referenciado por el procesador. Si, por el contrario, el bloque
no se ha cargado todavía cuando el procesador requiere el acceso, se produciría un fallo de
caché; justo lo que se quiere evitar.
El cálculo 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 cómo y dónde se podrían insertar estas instrucciones en un fragmento de un
programa.

7 memoria cache

Más contenido relacionado

La actualidad más candente (20)

Similar a 7 memoria cache (20)

Último (20)

7 memoria cache