Taller de Caché. Organización del Computador 1. Verano 2016

Transcripción

1 Taller de Caché Organización del Computador 1 Verano Introducción El presente taller consiste en una serie de ejercicios en los cuales se deberá realizar el seguimiento del estado de diferentes tipos de caché. Será posible utilizar el simulador de caché para validar los resultados. Luego, se implementará una nueva política de desalojo dentro del simulador y se realizarán comparaciones. 2. El simulador Para el taller implementamos una versión super alpha de un simulador de Caché. El simulador se puede descargar de la página de la materia. Éste implementa tres tipos de caches posibles y tiene la restricción de que la memoria que usa siempre direcciona a palabra. El simulador consiste de varias clases de Python explicadas a continuación. Para utilizar el simulador se debe descargar el archivo cache.py y desde una consola en el directorio donde se encuentra cache.py ejecutar las siguientes instrucciones para abrir la consola interactiva de Python e importar todas las clases del simulador: # Abre una nueva sesion interactiva de Python ipython # Luego, dentro de la consola de Python, importar las clases del simulador from cache import * 2.1. Clases de Caches implementadas CacheCorrespondenciaDirecta Esta clase simula una Caché de correspondencia directa. Sus parámetros son: memory: Lista de enteros que representan el contenido de la memoria cachesize: Cantidad de bytes de la caché nlines: Número de líneas de la caché cachealg: Función que implementa el algoritmo de sustitución Por ejemplo, para crear un simulador de caché de correspondencia directa con: tamaño de caché de 64 bytes, dos líneas, algoritmo de sustitución FIFO y memoria principal de 1 KB con todos ceros, se debe hacer: memory = [0 for i in range(2**10)] c = CacheCorrespondenciaDirecta(memory=memory, cachesize=64, nlines=2, cachealg=fifo) CacheTotalmenteAsociativa Esta clase simula una Caché totalmente asociativa y como parámetros toma: 1

2 memory: Lista de enteros que representan la memoria cachesize: Cantidad de bytes de la caché nlines: Número de líneas de la caché cachealg: Función que implementa el algoritmo de sustitución Por ejemplo, para crear un simulador de cache totalmente asociativa con: tamaño de cache de 32 bytes, 4 líneas, algoritmo de sustitución FIFO y memoria principal de 1 MB con todos ceros, se debe hacer: memory = [0 for i in range(2**20)] c = CacheTotalmenteAsociativa(memory=memory, cachesize=32, nlines=4, cachealg=fifo) CacheAsociativa NWays Esta clase simula una Caché asociativa de N vías y toma como parámetros: memory: Lista de enteros que reprenstan la memoria cachesize: Cantidad de bytes de la caché nways: Cantidad de vías nsets: Cantidad de sets cachealg: Función que implementa el algoritmo de sustitución Por ejemplo, para crear un simulador de caché asociativa de 4 vías de tamaño de cache de 64 bytes, 2 sets, algoritmo de sustitución MRU y memoria principal de 1 GB con todos ceros, se debe hacer: memory = [0 for i in range(2**30)] c = CacheAsociativa_NWays(memory=memory, cachesize=64, nways=4, nsets=2, cachealg=mru) 2.2. Métodos implementados Cada clase de caché simulada tiene algunos métodos implementados. fetch: Este método simula un pedido a memoria, toma como parámetro el address para buscar en la memoria info: Muestra información de la cache hitrate: Devuelve la tasa de hits 2.3. Estructuras internas Para poder simular el comportamiento de las caches cada clase tiene una estructura bastante simple, pero necesaria que entiendan para poder implementar los algoritmos de sustitución. Esencialmente se puede simplificar entendiendo que cada espacio disponible en la cache guarda la siguiente información valid: Es un flag que establece si el valor de la cache es válido o no stepchange: Guarda en que step se usó por ultima vez cada celda stepfirstuse: Guarda en que step se cargó en la cache esta celda address req: Guarda la dirección que se pidió para llenar esta celda mem: Guarda las direcciones de memorias que corresponden a esta linea La cache almacena el valor del step, que se aumenta cada vez que se hace un fetch, de este modo, podemos tener registro de en qué paso del a ejecución se creó y usó la cache. 2

3 2.4. Ejemplo de uso A continuación presentamos un ejemplo de uso de la cache from cache import * # Esto es un comentario en python # Creamos una memoria de solo 16 bytes memory = [0,0xA,0,0,0,0,0xF,0,0,0,0x5,0,0,0,0,0] # Creamos la memoria cache ca = CacheTotalmenteAsociativa(memory=memory, cachesize=16, nlines=2, cachealg=fifo) # Me fijo que hay en la linea 0 print ca.get_to_plot(line=0) # out: { stepchange : -1, stepfirstuse : -1, tag : None, valid : False} # el campo valido esta en False, porque no hay nada, # pues no hicimos ningun fetch Memoria B x0 0xA 0x0 0x0 B x0 0x0 0xF 0x0 B x0 0x0 0x5 0x0 B x0 0x0 0x0 0x0 Cache Indice Tag # Pido la memoria con direccion 0x6 ca.fetch(0x6) # Me fijo que guardo la cache print ca.get_to_plot(line=0) # out: # { mem : [0, 0, 15, 0], # address_req : 6, # tag : 1, # stepfirstuse : 0, # address : [4, 5, 6, 7], # stepchange : 0, # valid : True} # Me fijo en que step estoy print ca.step # out: 0 3

4 # Para ver el log, podemos hacer print ca.log # out: [{ address : 6, hit : False, line : 0, step : 0}] # Para ver el hitrate print ca.hitrate() # out: 0.0 El estado de la cache actual Cache Indice Tag x0 0x0 0xF 0x ca.fetch(0x1) # otro miss print ca.get_to_plot # out: { address : [0, 1, 2, 3], # address_req : 1, # mem : [0, 10, 0, 0], # stepchange : 1, # stepfirstuse : 1, # tag : 0, # valid : True} # Me fijo en que step estoy print ca.step # out: 1 print ca.hitrate() # out: 0 El estado de la cache actual Cache Indice Tag x0 0x0 0xF 0x0 0 0x0 0xA 0x0 0x0 Ahora vamos a hacer un fetch que produzca un hit! ca.fetch(0x4) print ca.hitrate() 4

5 # out: print ca.step # out: 2 print ca.get_to_plot(line=0) # { mem : [0, 0, 15, 0], # address_req : 6, # tag : 1, # stepfirstuse : 0, # address : [4, 5, 6, 7], # stepchange : 2, # valid : True} # Notar como el stepfirstuse==0 porque fue creado en el step 0, # pero stepchange, fue el dos por el fetch a 0x4 3. Ejercicios 3.1. Ejercicio 1 - Seguimiento de Caché Caché de correspondencia directa Considerar la máquina de ORGA1 (palabras y direccionamiento de 16 bits, memoria de 128 KB), y con una memoria caché de correspondencia directa de 128 B con líneas de 32 B. Suponiendo que la caché comienza vacía, determinar para la siguiente lista de accesos si se produce un hit o un miss en la caché completando la siguiente tabla. Se accede a las siguientes direcciones de memoria en este orden: 0x0009, 0x001D, 0x00A, 0x0101, 0x0113, 0x000A, 0x001E, 0x0102, 0x0114 Dirección Tag Linea (bits/decimal) Indice Rango de la ĺınea Hit/Miss 0x0009 0x001D 0x000A 0x0101 0x0113 0x000A 0x001E 0x0102 0x0114 Utilización del simulador Para validar las respuestas es posible utilizar el simulador. Para crear la cache, tener en cuenta que los tamaños estan expresados en palabras. # palabras y direccionamiento de 16 bits 5

6 # memoria de 128 KB (64 K = 2**16 palabras) # memoria cache de correspondencia directa de 128B (64 palabras=2**6) # con lineas de 32 B (son entonces 128/32=4 lineas) ca = CacheCorrespondenciaDirecta(memory=range(0, 2**16), cachesize=2**6, nlines=4) Para visualizar los campos que utiliza la caché para una direccion de memoria en particular, es posible utilizar la función getf ields(address) # muestra los campos de cache usados para la direccion de memoria 0x0009 ca._getfields(0x0009) -> { index : 9, tag : 0, set : 0} Para realizar una lectura de memoria es posible utlizar la función f etch. # realiza una lectura de la posicion de memoria 0x0009 ca.fetch(0x0009) La función log() muestra el historial de accesos a memoria caché. Cada ítem representa un acceso a caché. Cada ítem muestra la línea de cache que fue utilizada, si fue un miss o un hit, el numero de paso y la dirección de memoria que fue accedida. # muestra los hit y miss del historial de accesos print ca.log -> [{ line : 0, hit : False, step : 0, address : 9}] Para visualizar el estado de la memoria caché se puede utilizar la función print, y la función log() muestra el historial de hit y miss. Por ejemplo: # muestra el estado actual de la cache print ca # realiza una lectura de la posicion de memoria 0x000D ca.fetch(0x000d) Caché completamente asociativa Utilizando el simulador y la misma lista de accesos a memoria que en el punto anterior, complete la siguiente tabla utilizando a una memoria caché completamente asociativa de 128 B, líneas de 32 B y una política de desalojo FIFO. 6

7 Dirección Tag Indice # Linea Rango de la ĺınea Hit/Miss 0x0009 0x001D 0x000A 0x0101 0x0113 0x000A 0x001E 0x0102 0x0114 a) En qué casos funciona mejor una memoria de correspondencia directa frente a una completamente asociativa? b) Qué pasa si sólo uso caché para los datos? Y si sólo la uso para el código? Cómo distingo si una posición de memoria es dato o código? 7

8 3.2. Ejercicio 2 - Políticas de desalojo Implementación de LRU El simulador permite configurar las memoria caché para que utilice diferentes políticas de desalojo. Actualmente se encuentran implementadas las politicas FIFO y RANDOM. Puede verse su implementación en el archivo cache.py Utilizando las políticas ya existentes en el simulador, implemente una nueva política: Least-Recently-Used (LRU) que desaloje la línea que fue utilizada hace más tiempo. Las funciones de desalojo toman los siguientes parámetros: vías, valores del tag, valores del set. Vías refiere a la estructura interna ways de la cache. Por ejemplo, para la politica FIFO: def FIFO (ways, addr_tag, addr_set ): # Me fijo si alguna de las vias esta vacia, en ese caso devuelvo cual way_i =0 for way in ways : if way [ addr_set ][ valid ]== False : return way_ i way_i +=1 # Si estoy aca es que ninguna esta vacia, tengo que desalojar alguna # segun la politica FIFO, es decir tengo que sacar aquella que haya # sido ingresada primero, para eso chequeo tengo que devolver la que # tenga el stepfirstuse mas viejo ( numericamente menor ) menor_step = ways [0][ addr_set ][ stepfirstuse ] way_ menor_ step =0 i=0 for way in ways : if way [ addr_set ][ stepfirstuse ] < menor_step : # Encontre el minimo, actualizo menor_step = way [ addr_set ][ stepfirstuse ] way_menor_step =i i +=1 return way_ menor_ step Hit Rate Utilizando una configuración como en los ejercicios anteriores para una cache completamente asociativa, determinar el hit rate para esta nueva política al accederse a las direcciones definidas en el archivo benckmark.list Para esto es posible utilizar la función fetchf rom, que toma como parametro el nombre de un archivo y ejecuta fetch para cada una de las direcciones definidas en el archivo. Es posible utilizar también la funcion hitrate que utilizando el log de la cache devuelve el hit rate histórico. 8

9 # Traigo de memoria todas las direcciones en el order definido en benchmark. list ca. fetchfrom ( benchmark. list ) # Corroboro el hitrate de la cache ca. hitrate () a) Si utilizamos una política RANDOM para la misma lista de accesos, la cache se comporta mejor o peor? 9

10 3.3. Ejercicio 3 - Comparación de políticas Para comparar y reportar resultados, usar gráficos suele ser una buena idea. Por ejemplo, si quisieramos reportar como mejora la hit rate, dada una lista de accesos, a medida que aumentamos la cantidad de líneas podriamos hacerlo con el siguiente codigo from cache import * import pylab # Correspondencia directa, vario distintas lineas y guardo la hit rate # para cada configuracion usando la secuencia de fetchs definida en # benchmark. list dom = [1,2,4,8,16] res = [] for l in dom : ca = CacheCorrespondenciaDirecta ( memory = range (0, 2**16), cachesize =64, nlines =l, cachealg = FIFO ) ca. fetchfrom ( benchmark. list ) res. append ( ca. hitrate () ) print " Lineas :", l, " HitRate :", ca. hitrate () # res tiene los distintos valores de hit rates para cada configuracion # uso pylab para plotear pylab. plot (dom,res,.-,lw =2, label = CacheCorrespondenciaDirecta - FIFO ) pylab. xticks ( size =16) pylab. yticks ( size =16) pylab. xlabel ( Lineas,size =16) pylab. ylabel ( Hit Rate,size =16) pylab. title ( Cache Correspondencia Directa,size =16) pylab. show () Linea HitRate a) Propongan dos hipótesis, ideas, comportamientos esperados (o no) que puedan ser descriptos/contestados usando gráficos. Puede graficar en la herramienta que quieran (Excel, Calcs, Matlab, matplotlib ) 10