PDF de programación - Coherencia de cachés

Coherencia de cachés





© Todos los derechos de propiedad intelectual de esta obra pertenecen en exclusiva a la

Universidad Europea de Madrid, S.L.U. Queda terminantemente prohibida la reproducción,

puesta a disposición del público y en general cualquier otra forma de explotación de toda o parte

de la misma.



La utilización no autorizada de esta obra, así como los perjuicios ocasionados en los derechos de

propiedad intelectual e industrial de la Universidad Europea de Madrid, S.L.U., darán lugar al
ejercicio de las acciones que legalmente le correspondan y, en su caso, a las responsabilidades

que de dicho ejercicio se deriven.




Coherencia de cachés



Contenido



Presentación ........................................................................................................................ 4

Acceso a memoria caché en escritura ................................................................................. 5

Jerarquía de caché ............................................................................................................... 9

Esquemas básicos de coherencia de caché ....................................................................... 10

Protocolo snooping (o fisgoneo) ....................................................................................... 13

Snooping para write back .................................................................................................. 16

Coherencia basada en directorios ..................................................................................... 18

Modelos de directorios...................................................................................................... 20

Resumen ............................................................................................................................ 22

Referencias bibliográficas .................................................................................................. 23



© Universidad Europea de Madrid. Todos los derechos reservados.

3



Coherencia de cachés

Presentación



En este recurso veremos cómo solucionar el problema de la coherencia de caché cuando hay múltiples

procesadores, tanto en sistemas mono procesador con varios núcleos de procesamiento, como en

sistemas con varios procesadores distribuidos.

Analizaremos cuáles son los problemas de la jerarquía de caché en sistemas multiprocesadores y cuáles

son los métodos para evitar errores de caché, que se clasifican en:



Protocolo snooping (también llamado protocolo snoopy, o fisgoneo, en español):





Snooping para write through.

Snooping para write back.



Coherencia basada en directorios:

 Directorios full-map

 Directorios limitados.

 Directorios encadenados.

Objetivos

Los objetivos que se pretenden alcanzar con este recurso son los siguientes:





Analizar los problemas de ordenadores multi-procesador y el problema de la memoria caché.

Conocer los diferentes métodos que permiten asegurar la coherencia de caché en sistemas de

memoria compartida.

 Diferenciar los protocolos snooping y los grupos de protocolos basados en directorios.



© Universidad Europea de Madrid. Todos los derechos reservados.

4



Coherencia de cachés



Acceso a memoria caché en escritura

Ya hemos visto que la caché contiene una copia de algunos datos contenidos en la memoria. Nunca datos

propios. Un acierto de caché se considera cuando el procesador intenta acceder a un dato, dato que

siempre está en memoria, pero que a veces, este dato está replicado en memoria caché.

Y aquí es donde está la ventaja de la caché, si este dato se encuentra en caché, es la caché la que

responde al procesador simulando que ya se ha producido el acceso al dato en memoria, con una gran

ventaja, el tiempo de espera que el procesador ha tenido que emplear para recibir el dato solicitado es

muy inferior al tiempo que emplearía si el dato no se encontrara en caché.

Incoherencia de caché



Si los accesos son de tipo lectura, todo es perfecto pero, ¿qué pasa cuando un acceso a un dato es de

tipo escritura y la caché tiene una réplica del mismo? El acceso, otra vez más se para en la caché, por lo

que la memoria nunca se entera de que ha habido una modificación del dato. Consecuencia, el dato

almacenado en caché y el dato almacenado en memoria no son los mismos. Esto se conoce como

incoherencia de caché.



La incoherencia de caché tiene dos posibles soluciones, en función de la política de escritura que

empleemos:

Escritura inmediata: write through

Los accesos a caché en escritura, siempre

producen fallo de caché, por lo que la petición de

escritura siempre llega a la memoria principal. No

se puede dar problemas de caché, porque en

ningún momento el dato en memoria se queda

desactualizado. La operación de escritura se realiza

siempre en la memoria principal y en la memoria

caché.

Cuando hay un acceso de escritura y el dato se

encuentra en la caché, solamente se actualiza el

Escritura retardada: write back

dato en la memoria caché. Tanto la memoria



caché como la memoria principal, mantienen

información

interna de qué datos han sido

© Universidad Europea de Madrid. Todos los derechos reservados.

5




Coherencia de cachés



actualizados por una escritura en caché, y estos

datos antes de ser eliminados de caché, son

escritos en memoria. Los datos permanecen

desactualizados solo mientras hay una copia de

los mismos en caché, pero nunca se pierden

datos, porque

la caché es responsable de

actualizar la memoria antes de eliminar los datos

actualizados.



Ambos métodos funcionan bien, pero como siempre, no son perfectos.

La escritura inmediata es segura, pero poco eficiente, la escritura retardada, por el contrario,

penaliza más los fallos de caché.



Poco eficiente

Todos los accesos a memoria en escritura provocan fallo de caché, lo que reduce a la mitad el índice de

aciertos por parte de la caché.

Hay técnicas que mejoran este problema, dejando la responsabilidad a la caché de actualizar el dato en

memoria y que el procesador continúe con la ejecución de código antes de que la memoria se actualice

por completo. El inconveniente es que carga de trabajo a la caché, haciéndola sustancialmente más

lenta.



Penaliza más los fallos de caché.

Si hay un fallo de caché y hay que reemplazar un bloque de datos de la misma cuando el bloque tiene

activada la señal de bloque modificado. Antes de proceder al reemplazo, hay que escribir el bloque en

memoria y después proceder a la carga del nuevo bloque. Esto añade retrasos en la caché, cada vez que

hay que reemplazar un bloque que esta modificado.

Al igual que en el caso anterior, hay técnicas que mejoran este comportamiento. Una de ellas es hacer

que la caché, en sus momentos ociosos y de manera autónoma, revise qué bloques se han modificado y

vaya actualizando la memoria, para que si hay reemplazo sobre ellos, ya se haya realizado la mitad del

trabajo.



© Universidad Europea de Madrid. Todos los derechos reservados.

6



Coherencia de cachés



Multiprocesadores o multinúcleos



En la actualidad, la mayoría de las computadoras que se comercializan incluyen un sistema

multiprocesador o multinúcleo. A la hora de diseñar estos sistemas hay que pensar cómo se

organiza la jerarquía de memoria. Es especialmente crítico el uso de las memorias cachés y el

establecimiento de las políticas de ubicación y escritura más óptimas.

Diferenciemos multiprocesadores y multinúcleos:



Multiprocesador

Maquina con dos o más procesadores completos. Normalmente, podemos hablar de una sola maquina

con más de un procesador o incluso en dos máquinas diferentes.

Multinúcleo

Procesador con dos o más núcleos en un solo chip. Una máquina que tiene un solo procesador instalado.

Este procesador internamente está construido por más de un núcleo funcional.



En ambas maquinas, la jerarquía de memoria es muy diferente, pero ambas tienen un problema, aunque

sea a niveles diferentes.

Una variable compartida por más de un procesador, está

replicada en

los sistemas de memoria caché de cada

procesador. Esto permite agilizar los accesos a esa variable, y

explotar al máximo la existencia de la caché.

La variable compartida está replicada en la memoria común a

todos los procesadores, por tanto, no es un dato local.

Además, está replicada en cada una de las memorias locales

ya que el acceso a los datos debe ser lo más rápido posible,

consiguiendo reducir latencia (tiempo de lectura) en los

accesos.

Tras una serie de accesos al dato en escritura, las tres copias

de la variable, tendrán datos diferentes. ¿Por qué? Porque

no es suficiente con que cada procesador se encargue de

mantener correcto el valor de la variable en la memoria

compartida cada vez que se actualiza, sino que es necesario

que esta compruebe si su valor es correcto antes de acceder

¿Qué pasa con un dato que se necesite

en más de un procesador?



¿Qué pasa si el acceso a esta variable, no

es solo en lectura?



© Universidad Europea de Madrid. Todos los derechos reservados.

7



Coherencia de cachés



a él en lectura.



Máquina con dos procesadores

Supongamos una maquina con dos procesadores. Cada procesador tiene una memoria caché local y una

memoria