Documento

 INGENIERÍA INFORMÁTICA PROYECTO FINAL DE CARRERA ANÁLISIS TLB CURSO 2008­2009 Autora: Mónica Larruy Carrete
e-mail: [email protected]
Tutor: Carlos Molina Clemente
e-mail: [email protected]
PFC: Análisis TLB – Mónica Larruy Carrete ÍNDICE
1. ABSTRACT ................................................................................................................................. 16 2. PROYECTO REALIZADO ............................................................................................................. 17 3. INTRODUCCIÓN ........................................................................................................................ 19 3.1. SEGMENTACIÓN DE CAUCE Y PROCESADORES SEGMENTADOS ...................................... 19 3.1.1. Conceptos teóricos ................................................................................................... 19 3.1.2. Notas históricas ........................................................................................................ 19 3.1.3. Microprocesadores segmentados ............................................................................ 20 3.2. MICROPROCESADORES SUPERESCALARES ....................................................................... 21 3.3. LA MEMORIA .................................................................................................................... 24 3.4. Gestión de la memoria ..................................................................................................... 26 3.4.1. Requisitos de la gestión de memoria ....................................................................... 26 3.4.2. Memoria principal o real .......................................................................................... 27 3.4.2.1. Asignación contigua .......................................................................................... 27 Particiones estáticas ......................................................................................................... 27 Particiones dinámicas ....................................................................................................... 28 3.4.2.2. 3.4.3. Asignación no contigua .................................................................................... 28 Paginación simple ..................................................................................................... 28 3.4.3.1. Fundamentos .................................................................................................... 28 3.4.3.2. Paginación ........................................................................................................ 29 3.4.3.3. Tamaño de la página ........................................................................................ 31 3.4.3.4. Implementación de la tabla de páginas (TP) .................................................... 32 3.4.4. Segmentación simple ............................................................................................... 32 3.4.4.1. Traducción de direcciones segmentadas ......................................................... 33 3.4.4.2. Protección ......................................................................................................... 34 3.4.4.3. Fragmentación .................................................................................................. 35 3.4.5. Paginación vs Segmentación .................................................................................... 36 3.4.5.1. Fragmentación .................................................................................................. 36 1) Fragmentación interna (paginación) ........................................................................ 36 2) Fragmentación externa (segmentación) .................................................................. 37 3.4.5.2. Ejemplo de traducción de dirección lógica a física ........................................... 37 3
PFC: Análisis TLB – Mónica Larruy Carrete Paginación .................................................................................................................... 37 Segmentación ............................................................................................................... 38 3.4.5.3. Comparativa general ........................................................................................ 38 3.4.5.4. Paginación: Ventajas e Inconvenientes ............................................................ 39 Ventajas ........................................................................................................................ 39 Inconvenientes ............................................................................................................. 39 3.4.5.5. Segmentación: Ventajas e Inconvenientes ...................................................... 40 Ventajas ........................................................................................................................ 40 Inconvenientes ............................................................................................................. 40 3.4.6. Memoria virtual ........................................................................................................ 41 3.4.6.1. Objetivos de la memoria virtual ....................................................................... 43 3.4.6.2. Paginación ........................................................................................................ 43 Traducción de direcciones ................................................................................................ 44 Tratamiento del fallo de página ....................................................................................... 46 3.4.6.3. Segmentación ................................................................................................... 47 Traducción de direcciones ................................................................................................ 47 3.4.6.4. Características de la paginación y la segmentación ......................................... 48 3.4.6.5. Paginación y segmentación combinadas .......................................................... 49 Ventajas ............................................................................................................................ 50 Inconvenientes ................................................................................................................. 50 3.4.7. 4. TLB (Translation Lookaside Buffer) ........................................................................................... 52 4.1. Introducción ..................................................................................................................... 52 4.1.1. Técnicas de gestión de memoria .............................................................................. 51 Soporte hardware a las tablas de páginas (TP) ........................................................ 52 4.1.1.1. Registros dedicados .......................................................................................... 52 4.1.1.2. Registros asociativos (TLB) ............................................................................... 53 4.2. Funcionamiento................................................................................................................ 53 4.3. Diseño ............................................................................................................................... 54 4.4. Acceso ............................................................................................................................... 55 4.5. Reemplazo ........................................................................................................................ 56 4.6. Gestión de los fallos de página y del TLB ......................................................................... 57 4.7. TLB gestionado por software ........................................................................................... 58 4.8. Indexación TLB .................................................................................................................. 59 4.9. Tamaño de página ............................................................................................................ 60 4
PFC: Análisis TLB – Mónica Larruy Carrete 4.10. Entrada TLB ................................................................................................................... 61 4.10.1. Valores típicos de parámetros para un TLB .............................................................. 61 4.11. Integración de la memoria virtual, los TLBs y las cachés ............................................. 62 4.12. IMPLEMENTACIONES.................................................................................................... 64 4.12.1. Introducción ............................................................................................................. 64 4.12.2. VAX‐11/780 .............................................................................................................. 64 4.12.3. MIPS R2000 .............................................................................................................. 65 4.12.3.1. Gestión de los fallos ......................................................................................... 67 4.12.4. Intel ........................................................................................................................... 67 4.12.4.1. Intel I960 ........................................................................................................... 67 4.12.4.2. Familia Pentium ................................................................................................ 67 Esquema ........................................................................................................................... 67 Paginación‐Segmentación ................................................................................................ 69 Funcionamiento del hardware de paginación. ................................................................. 70 Registros de control usados para la paginación ............................................................... 71 Registros de test ............................................................................................................... 71 TR6 .................................................................................................................................... 72 TR7 .................................................................................................................................... 73 Registros ........................................................................................................................... 73 Acceso TLB ........................................................................................................................ 74 Resumen TLB en procesadores Pentium .......................................................................... 74 4.12.5. Pentinum Pro ............................................................................................................ 75 4.12.5.1. Introducción ..................................................................................................... 75 4.12.5.2. Características .................................................................................................. 75 4.12.6. Core 2 Duo ................................................................................................................ 76 4.12.6.1. Caché ................................................................................................................ 76 4.12.6.2. TLB .................................................................................................................... 77 Segundo Nivel Caché ........................................................................................................ 77 4.12.7. IBM ........................................................................................................................... 78 4.12.7.1. Power‐1 ............................................................................................................ 78 4.12.8. AMD .......................................................................................................................... 79 4.12.8.1. K5 ...................................................................................................................... 79 4.12.8.2. AMD Athlon: K7 ................................................................................................ 79 Fase de búsqueda de instrucción ..................................................................................... 80 5
PFC: Análisis TLB – Mónica Larruy Carrete Instrucciones Caché .......................................................................................................... 81 Datos Caché ...................................................................................................................... 81 Introducción ..................................................................................................................... 82 TLB .................................................................................................................................... 82 5. AMD K10 Barcelona 65nm................................................................................ 83 4.12.8.4. AMD K10 (AMD Phenom) ................................................................................. 83 HERRAMIENTAS UTILIZADAS .................................................................................................... 85 5.1. SimpleScalar ..................................................................................................................... 85 5.1.1. Funcionamiento ........................................................................................................ 85 5.1.2. Características .......................................................................................................... 85 5.1.3. Modalidades de simulación ...................................................................................... 86 5.2. 6. 4.12.8.3. CACTI ................................................................................................................................ 87 5.2.1. Introducción ............................................................................................................. 87 5.2.2. Funcionamiento ........................................................................................................ 88 ESTUDIO ESTÁTICO CON CACTI ................................................................................................ 89 6.1. Introducción ..................................................................................................................... 89 6.2. Resultados extraídos ........................................................................................................ 90 6.3. Modificaciones CACTI ....................................................................................................... 91 6.3.1. Independizar resultados ........................................................................................... 91 6.3.2. Eliminar restricciones de tamaño del TLB ................................................................ 92 6.3.3. Modificar mínimo de escala de integración ............................................................. 92 6.4. Parámetros y valores estudiados ..................................................................................... 93 6.4.1. 6.4.1.1. Tiempo de acceso ............................................................................................. 94 6.4.1.2. Área .................................................................................................................. 95 6.4.1.3. Consumo lectura .............................................................................................. 96 6.4.1.4. Consumo escritura............................................................................................ 97 6.4.1.5. Comparativa: Consumo lectura vs consumo escritura ..................................... 97 6.4.2. Estudio del grado de asociatividad ........................................................................... 94 Estudio del tamaño de línea ..................................................................................... 98 6.4.2.1. Tiempo de acceso ............................................................................................. 98 6.4.2.2. Área .................................................................................................................. 99 6.4.2.3. Consumo lectura .............................................................................................. 99 6.4.2.4. Consumo escritura.......................................................................................... 100 6
PFC: Análisis TLB – Mónica Larruy Carrete 6.4.2.5. 6.4.3. Escala de integración .............................................................................................. 101 6.4.3.1. Tiempo de acceso ........................................................................................... 102 6.4.3.2. Área ................................................................................................................ 103 6.4.3.3. Consumo lectura ............................................................................................ 104 6.4.3.4. Consumo escritura.......................................................................................... 104 6.4.3.5. Comparativa: consumo lectura vs consumo escritura ................................... 105 6.4.4. Puertos lectura y escritura ..................................................................................... 106 6.4.4.1. Tiempo de acceso ........................................................................................... 106 6.4.4.2. Área ................................................................................................................ 107 6.4.4.3. Consumo: lectura y escritura .......................................................................... 108 6.4.4.4. Evolución consumo puertos lectura ............................................................... 109 6.4.5. Evolución consumo puertos escritura .................................................................... 110 6.4.5.1. 7. Comparativa: consumo lectura vs consumo escritura ................................... 100 Comparativa: consumo lectura vs consumo escritura ................................... 110 ESTUDIO DINÁMICO CON SIMPLESCALAR .............................................................................. 111 7.1. Introducción ................................................................................................................... 111 7.2. Llamadas al sistema ........................................................................................................ 112 7.3. Ejecución dinámica ......................................................................................................... 113 7.4. Predicción de saltos ........................................................................................................ 113 7.5. Jerarquía memoria ......................................................................................................... 114 7.6. El Pipeline ....................................................................................................................... 114 7.6.1. Etapa fetch .............................................................................................................. 114 7.6.2. Etapa dispatch ........................................................................................................ 115 7.6.3. Etapa issue .............................................................................................................. 115 7.6.4. Etapa execute ......................................................................................................... 116 7.6.5. Etapa writeback ...................................................................................................... 116 7.6.6. Etapa commit .......................................................................................................... 116 7.7. Cargas de trabajo (Benchmarks SPEC2000).................................................................... 117 7.8. Entorno y diseño ............................................................................................................ 118 7.8.1. Arquitectura de simulación .................................................................................... 118 7.8.2. Modificaciones SimpleScalar .................................................................................. 120 7.8.3. Configuración simulador ........................................................................................ 132 7.9. Análisis estudio dinámico con SimpleScalar mediante SPECs ........................................ 136 Gráficas ........................................................................................................................... 137 7
PFC: Análisis TLB – Mónica Larruy Carrete 7.9.1. bzip ......................................................................................................................... 138 7.9.1.1. IPC ................................................................................................................... 138 7.9.1.2. Miss_rate ........................................................................................................ 138 7.9.1.3. Tiempo de acceso ........................................................................................... 140 7.9.2. gcc ........................................................................................................................... 141 7.9.2.1. IPC ................................................................................................................... 141 7.9.2.2. Miss_rate ........................................................................................................ 141 7.9.2.3. Tiempo de acceso ........................................................................................... 143 7.9.3. gzip ......................................................................................................................... 144 7.9.3.1. IPC ................................................................................................................... 144 7.9.3.2. Miss_rate ........................................................................................................ 144 7.9.3.3. Tiempo de acceso ........................................................................................... 146 7.9.4. mcf .......................................................................................................................... 147 7.9.4.1. IPC ................................................................................................................... 147 7.9.4.2. Miss_rate ........................................................................................................ 147 7.9.4.3. Tiempo de acceso ........................................................................................... 149 7.9.5. vortex ...................................................................................................................... 150 7.9.5.1. IPC ................................................................................................................... 150 7.9.5.2. Miss_rate ........................................................................................................ 150 7.9.5.3. Tiempo de acceso ........................................................................................... 152 7.9.6. vpr ........................................................................................................................... 153 7.9.6.1. IPC ................................................................................................................... 153 7.9.6.2. Miss_rate ........................................................................................................ 153 7.9.6.3. Tiempo de acceso ........................................................................................... 155 7.9.7. art ........................................................................................................................... 156 7.9.7.1. IPC ................................................................................................................... 156 7.9.7.2. Miss_rate ........................................................................................................ 156 7.9.7.3. Tiempo de acceso ........................................................................................... 158 7.9.8. equake .................................................................................................................... 159 7.9.8.1. IPC ................................................................................................................... 159 7.9.8.2. Miss_rate ........................................................................................................ 159 7.9.8.3. Tiempo de acceso ........................................................................................... 161 7.9.9. mesa ....................................................................................................................... 162 7.9.9.1. IPC ................................................................................................................... 162 8
PFC: Análisis TLB – Mónica Larruy Carrete 7.9.9.2. Miss_rate ........................................................................................................ 162 7.9.9.3. Tiempo de acceso ........................................................................................... 164 7.9.10. Conclusiones estudio dinámico .............................................................................. 165 8. CRONOGRAMA TEMPORAL (diagrama de Gantt) .................................................................. 166 9. CONCLUSIONES ...................................................................................................................... 169 10. RECURSOS UTILIZADOS .......................................................................................................... 173 10.1. Bibliografía .................................................................................................................. 173 10.2. Páginas webs .............................................................................................................. 174 10.2.1. Gestión de la memoria ........................................................................................... 174 10.2.2. Paginación, segmentación ...................................................................................... 174 10.2.3. Arquitectura superescalar ...................................................................................... 175 10.2.4. TLB .......................................................................................................................... 175 10.2.5. Implementaciones reales ....................................................................................... 175 10.2.6. CACTI ...................................................................................................................... 176 10.2.7. SimpleScalar ........................................................................................................... 176 10.2.7.1. Instalación ...................................................................................................... 176 10.3. Software ..................................................................................................................... 177 10.4. Hardware .................................................................................................................... 177 ANEXO ............................................................................................................................................ 178 9
PFC: Análisis TLB – Mónica Larruy Carrete ÍNDICE FIGURAS Figura 1: Evolución de las instrucciones a través de las diferentes etapas de un microprocesador segmentado .............................................................................................................................. 20 Figura 2: Evolución de las instrucciones a través de las diferentes etapas de un microprocesador superescalar con dos trayectos segmentados de seis etapas cada uno .................................. 21 Figura 3: Microarquitectura para un procesador segmentado capaz de procesar dos instrucciones por ciclo .................................................................................................................................... 22 Figura 4: Microarquitectura más usual en procesadores superescalares ........................................ 22 Figura 5: Jerarquía usual de memoria .............................................................................................. 24 Figura 6: Caché y memoria principal ................................................................................................ 24 Figura 7: Esquema paginación .......................................................................................................... 29 Figura 8: Estructura dirección lógica ................................................................................................ 30 Figura 9: Ejemplo de traducción de direcciones mediante paginación ........................................... 30 Figura 10: Traducción de direcciones mediante segmentación ....................................................... 33 Figura 11: Esquema protección en segmentación ........................................................................... 34 Figura 12: Fragmentación interna .................................................................................................... 36 Figura 13: Fragmentación externa ................................................................................................... 37 Figura 14: Ejemplo de traducción de dirección lógica a física mediante paginación ....................... 37 Figura 15: Ejemplo de traducción de dirección lógica a física mediante segmentación .................. 38 Figura 16: Formato dirección virtual en memoria virtual basada en paginación ............................ 44 Figura 17: Entrada de la TP en memoria virtual basada en paginación ........................................... 44 Figura 18: Traducción de direcciones mediante paginación en memoria virtual ............................ 45 Figura 19: Formato dirección virtual en memoria virtual basada en segmentación ....................... 47 Figura 20: Entrada de la TS en memoria virtual basada en segmentación ...................................... 47 Figura 21: Traducción de direcciones mediante segmentación en memoria virtual ....................... 47 Figura 22: Traducción de direcciones en un sistema con paginación y segmentación en memoria virtual........................................................................................................................................ 49 Figura 23: Formato de la etiqueta de la entrada del TLB ................................................................. 53 Figura 24: Uso del TLB ...................................................................................................................... 55 Figura 25: Funcionamiento de la paginación con TLB ...................................................................... 56 Figura 26: Búsqueda directa y asociativa en entradas de la tabla de páginas ................................. 59 Figura 27: Traducción con TLB y uso de caché ................................................................................. 60 Figura 28: TLB del VAX‐11/780 ......................................................................................................... 64 10
PFC: Análisis TLB – Mónica Larruy Carrete Figura 29: TLB del MIPS R2000 ......................................................................................................... 65 Figura 30: Uso TLB en la DECStation 3100 ....................................................................................... 66 Figura 31: Diagrama de bloques del procesador Pentium ............................................................... 69 Figura 32: Registros de control para la paginación en el procesador Pentium................................ 71 Figura 33: Registros TLB ................................................................................................................... 72 Figura 34: Resumen de las características del PowerPC 604 ........................................................... 78 Figura 35: Diagrama de bloques del microprocesador K7 de AMD, con su sistema de decodificación en paralelo y sus dos cauces de ejecución (uno para enteros y otro para números de coma flotante) ...................................................................................................... 79 Figura 36: Diagrama de bloques del procesador superescalar Athlon de AMD .............................. 80 Figura 37: Captura con RMMA (RightMark Memory Analyzer) de las características del TLB en un AMD K8 ................................................................................................................................... ..82 Figura 38: Modalidades de simulación integradas en SimpleScalar ................................................ 86 Figura 39: Estructura caché usada en CACTI .................................................................................... 89 Figura 40: Tiempo acceso en función del grado de asociatividad .................................................... 94 Figura 41: Área en función del grado de asociatividad .................................................................... 96 Figura 42: Consumo lectura en función del grado de asociatividad ................................................ 96 Figura 43: Consumo escritura en función del grado de asociatividad ............................................. 97 Figura 44: Comparativa consumo en función del grado de asociatividad ....................................... 97 Figura 45: Tiempo de acceso en función del tamaño de línea ......................................................... 98 Figura 46: Área en función del tamaño de línea .............................................................................. 99 Figura 47: Consumo lectura en función del tamaño de línea .......................................................... 99 Figura 48: Consumo escritura en función del tamaño de línea ..................................................... 100 Figura 49: Comparativa consumo en función del tamaño de línea ............................................... 100 Figura 50: Tiempo de acceso en función de la escala de integración ............................................ 102 Figura 51: Área en función de la escala de integración.................................................................. 103 Figura 52: Consumo lectura en función de la escala de integración .............................................. 104 Figura 53: Consumo escritura en función de la escala de integración ........................................... 104 Figura 54: Comparativa consumo en función de la escala de integración ..................................... 105 Figura 55: Tiempo de acceso en función del número de puertos de lectura y escritura ............... 106 Figura 56: Área en función del número de puertos de lectura y escritura .................................... 107 Figura 57: Consumo de lectura y escritura en función del número de puertos ............................ 108 Figura 58: Evolución del consumo de los puertos de lectura ........................................................ 109 Figura 59: Evolución del consumo de los puertos de escritura ...................................................... 110 11
PFC: Análisis TLB – Mónica Larruy Carrete Figura 60: Comparativa consumo lectura y consumo escritura ..................................................... 110 Figura 61: Módulos que forman el simulador sim‐outorder .......................................................... 112 Figura 62: bucle principal del simulador sim‐outorder .................................................................. 112 Figura 63: Espacio de memoria de SimpleScalar basado en la arquitectura PISA ......................... 113 Figura 64: Pipeline del procesador sim‐outorder del SimpleScalar ............................................... 114 Figura 65: Comparativa IPC SPECINT bzip con y sin TLB L2……. ..................................................... 138 Figura 66: Miss_rate SPECINT bzip para TLB sólo con L1…….......................................................... 138 Figura 67: Miss_rate SPECINT bzip para TLB con L1 y L2 ............................................................... 138 Figura 68: Comparativa miss_rate SPECINT bzip con y sin TLB L2 ................................................. 139 Figura 69: Comparativa tiempo de acceso SPECINT bzip con y sin TLB L2 ..................................... 140 Figura 70: Comparativa IPC SPECINT gcc con y sin TLB L2……. ....................................................... 141 Figura 71: Miss_rate SPECINT gcc para TLB sólo con L1 ................................................................ 142 Figura 72: Miss_rate SPECINT gcc para TLB con L1 y L2 ................................................................. 142 Figura 73: Comparativa miss_rate SPECINT gcc con y sin TLB L2 ................................................... 142 Figura 74: Comparativa tiempo de acceso SPECINT gcc con y sin TLB L2 ...................................... 143 Figura 75: Comparativa IPC SPECINT gzip con y sin TLB L2…………… .............................................. 144 Figura 76: Miss_rate SPECINT gzip para TLB sólo con L1 ............................................................... 145 Figura 77: Miss_rate SPECINT gzip para TLB con L1 y L2................................................................ 145 Figura 78: Comparativa miss_rate SPECINT gzip con y sin TLB L2.................................................. 145 Figura 79: Comparativa tiempo de acceso SPECINT gzip con y sin TLB L2 ..................................... 146 Figura 80: Comparativa IPC SPECINT mcf con y sin TLB L2……… .................................................... 147 Figura 81: Miss_rate SPECINT mcf para TLB sólo con L1 ................................................................ 147 Figura 82: Miss_rate SPECINT mcf para TLB con L1 y L2 ................................................................ 147 Figura 83: Comparativa miss_rate SPECINT mcf con y sin TLB L2 .................................................. 148 Figura 84: Comparativa tiempo de acceso SPECINT mcf con y sin TLB L2 ..................................... 149 Figura 85: Comparativa IPC SPECINT vortex con y sin TLB L2…...................................................... 149 Figura 86: Miss_rate SPECINT vortex para TLB sólo con L1……… ................................................... 150 Figura 87: Miss_rate SPECINT vortex para TLB con L1 y L2 ............................................................ 150 Figura 88: Comparativa miss_rate SPECINT vortex con y sin TLB L2 .............................................. 151 Figura 89: Comparativa tiempo de acceso SPECINT vortex con y sin TLB L2 ................................. 152 Figura 90: Comparativa IPC SPECINT vpr con y sin TLB L2……. ....................................................... 153 Figura 91: Miss_rate SPECINT vpr para TLB sólo con L1 ................................................................ 153 Figura 92: Miss_rate SPECINT vpr para TLB con L1 y L2 ................................................................. 153 Figura 93: Comparativa miss_rate SPECINT vpr con y sin TLB L2 ................................................... 154 12
PFC: Análisis TLB – Mónica Larruy Carrete Figura 94: Comparativa tiempo de acceso SPECINT vpr con y sin TLB L2 ...................................... 155 Figura 95: Comparativa IPC SPECFP art con y sin TLB L2………. ...................................................... 156 Figura 96: Miss_rate SPECFP art para TLB sólo con L1 ................................................................... 156 Figura 97: Miss_rate SPECFP art para TLB con L1 y L2 ................................................................... 156 Figura 98: Comparativa miss_rate SPECFP art con y sin TLB L2 ..................................................... 157 Figura 99: Comparativa tiempo de acceso SPECFP art con y sin TLB L2 ........................................ 158 Figura 100: Comparativa IPC SPECFP equake con y sin TLB L2 ...................................................... 159 Figura 101: Miss_rate SPECFP equake para TLB sólo con L1 ......................................................... 159 Figura 102: Miss_rate SPECFP equake para TLB con L1 y L2 .......................................................... 159 Figura 103: Comparativa miss_rate SPECFP equake con y sin TLB L2 ............................................ 160 Figura 104: Comparativa tiempo de acceso SPECFP equake con y sin TLB L2 ............................... 161 Figura 105: Comparativa IPC SPECFP mesa con y sin TLB L2…………….. .......................................... 162 Figura 106: Miss_rate SPECFP mesa para TLB sólo con L1 ............................................................. 162 Figura 107: Miss_rate SPECFP mesa para TLB con L1 y L2 ............................................................. 162 Figura 108: Comparativa miss_rate SPECFP mesa con y sin TLB L2 ............................................... 163 Figura 109: Comparativa tiempo de acceso SPECFP mesa con y sin TLB L2 .................................. 164 Figura 110: Cronograma temporal (diagrama de Gantt) con las diferentes fases en la realización del proyecto….…………………………………………………………………………………………………………..…………….. 163 Figura 111: Argumentos del simulador sim‐outorder .................................................................... 183 13
PFC: Análisis TLB – Mónica Larruy Carrete ÍNDICE TABLAS Tabla 1: Ejemplos de tamaños de páginas ....................................................................................... 32 Tabla 2: Posibles implementaciones de la TP ................................................................................... 32 Tabla 3: Comparativa entre paginación y segmentación ................................................................. 39 Tabla 4: Características de la paginación y la segmentación ........................................................... 49 Tabla 5: Resumen de las técnicas de gestión de memoria .............................................................. 51 Tabla 6: Ejemplo de entradas del TLB .............................................................................................. 61 Tabla 7: Valores típicos de parámetros para TLB ............................................................................. 61 Tabla 8: Posibles sucesos entre memoria virtual, caché y TLB………………………………………………........61 Tabla 9: Valores de los bits del registro TR6 de Pentium ................................................................. 72 Tabla 10: Resumen características Intel Pentium Pro ...................................................................... 75 Tabla 11: Comparativa de la capacidad TLB entre AMD K8 y AMD K10 .......................................... 84 Tabla 12: Benchmarks SPEC2000 de aritmética de enteros ........................................................... 117 Tabla 13: Benchmarks SPEC2000 de punto flotante ...................................................................... 118 Tabla 14: Valores comunes empleados para la simulación del TLB con y sin L2 ........................... 132 Tabla 15: Valor de los parámetros número de líneas, tamaño de página y asociatividad en función del tamaño del TLB ................................................................................................................. 134 Tabla 16: Configuración TLB (L1 y L2) de 384 bytes ....................................................................... 135 Tabla 17: Configuración TLB (L1 y L2) de 768 bytes ....................................................................... 135 Tabla 18: Configuración TLB (L1 y L2) de 1536 bytes ..................................................................... 135 Tabla 19: Configuración TLB (L1 y L2) de 3072 bytes ..................................................................... 135 Tabla 20: Configuración TLB (L1 y L2) de 6144 bytes ..................................................................... 136 Tabla 21: Valores de bzip IPC en función del TLB………………….. ..................................................... 138 Tabla 22: Valores miss_rate bzip para TLB con L1 y L2………………….. ............................................. 138 Tabla 23: Valores tiempo acceso SPECINT bzip en función del TLB ............................................... 140 Tabla 24: Valores IPC de gcc en función del TLB……………………………………….. ................................. 141 Tabla 25: Valores miss_rate gcc para TLB sólo con L1 ................................................................... 142 Tabla 26: Valores miss_rate gcc para TLB sólo con L1 y L2 ............................................................ 142 Tabla 27: Valores tiempo acceso SPECINT gcc en función del TLB ................................................ 143 Tabla 28: Valores IPC de gzip en función del TLB…………………………………. ...................................... 144 Tabla 29: Valores miss_rate gzip para TLB sólo con L1…………………………………. ............................. 144 Tabla 30: Valores miss_rate gzip para TLB sólo con L1……………………………. ................................... 144 Tabla 31: Valores tiempo acceso SPECINT gzip en función del TLB ............................................... 146 14
PFC: Análisis TLB – Mónica Larruy Carrete Tabla 32: Valores IPC de mcf en función del TLB……………… ........................................................... 148 Tabla 33: Valores miss_rate mcf para TLB sólo con L1. ................................................................. 148 Tabla 33: Valores miss_rate mcf para TLB sólo con L1 y L2 ........................................................... 148 Tabla 35: Valores tiempo acceso SPECINT mcf en función del TLB ................................................ 149 Tabla 36: Valores IPC de vortex en función del TLB……………………………… ...................................... 150 Tabla 37: Valores miss_rate vortex para TLB sólo con L1…………………………………………………………..149 Tabla 38: Valores miss_rate vortex para TLB con L1 y L2………………….. ......................................... 151 Tabla 39: Valores tiempo acceso SPECINT vortex en función del TLB ........................................... 152 Tabla 40: Valores IPC de vpr en función del TLB……………………………. ............................................ 153 Tabla 41: Valores miss_rate vpr para TLB sólo con L1……………………………………………………………….152 Tabla 42: Valores miss_rate vpr para TLB con L1 y L2 .................................................................... 154 Tabla 43: Valores tiempo acceso SPECINT vpr en función del TLB ................................................ 155 Tabla 44: Valores IPC de art en función del TLB………………………… ................................................. 156 Tabla 45: Valores miss_rate art para TLB sólo con L1 .................................................................... 157 Tabla 46: Valores miss_rate art para TLB con L1 y L2 .................................................................... 157 Tabla 47: Valores tiempo acceso SPECFP art en función del TLB ................................................... 158 Tabla 48: Valores IPC de equake en función del TLB…………………………….. ..................................... 159 Tabla 49: Valores miss_rate equake para TLB sólo con L1 ............................................................. 160 Tabla 50: Valores miss_rate equake para TLB con L1 y L2 ............................................................. 160 Tabla 51: Valores tiempo acceso SPECFP equake en función del TLB ........................................... 161 Tabla 52: Valores IPC de mesa en función del TLB……………………………. ......................................... 162 Tabla 53: Valores miss_rate mesa para TLB sólo con L1 ............................................................... 161 Tabla 54: Valores miss_rate mesa para TLB con L1 y L2 ................................................................ 163 Tabla 55: Valores tiempo acceso SPECFP mesa en función del TLB ............................................... 164 15
PFC: Análisis TLB – Mónica Larruy Carrete 1. ABSTRACT El buffer de traducción anticipada (TLB) es la unidad funcional responsable de retener las traducciones más eficientes (funcionando como una caché cuyos datos son direcciones físicas, y si se acierta en el acceso a la misma, la traducción tiene lugar en un solo ciclo). Éste es un elemento importante en la jerarquía de memoria en la que oculta la sobrecarga de mantener memoria virtual. Sin embargo, ciertas tendencias en diseño de ordenadores están aumentando la demanda en el TLB. El alcance de los actuales TLBs no es suficiente para apoyar dicha demanda, conllevando así a una inaceptable fracción del tiempo total de ejecución a tratar fallos de TLB. El tiempo de ciclo y el área prohíben la solución por fuerza bruta; escalar el tamaño del TLB. Así pues, las simulaciones realizadas en este proyecto tienen como objetivo el estudio de la eficacia del nivel dos (L2) de TLBs como medio para alcanzar el aumento general de TLB. El buffer de traducció anticipada (TLB) és la unitat funcional responsable de retenir les traduccions més eficients (funcionant com una caché on les seves dades són adreces físiques, i si s’encerta en l’accés a la mateixa, la traducció té lloc en un únic cicle). Aquest és un element important en la jerarquia de memòria en la que s’oculta la sobrecàrrega de mantenir memòria virtual. Tanmateix, certes tendències en disseny d’ordinadors estan augmentant la demanda en el TLB. L’abast dels actuals TLBs no és prou com per pujar aquesta demanda, comportant així a una inacceptable fracció del temps total d’execució a tractar fallades de TLB. El temps de cicle i l’àrea prohibeixen la solució per força bruta; escalar la mida del TLB. Així doncs, les simulacions realitzades en aquest projecte tenen com objectiu l’estudi de l’eficàcia del nivell dos (L2) de TLBs com mitjà per assolir l’augment general del TLB. The translation lookaside buffer is the functional unit responsible for retaining the translations more efficient (functioning as a cache for which data are physical addresses, and if it succeeds in access, translation takes place in a single cycle). This is a key component of the memory hierarchy in that it hides the overhead of maintaining virtual memory. However, certain trends in computer design are increasing the demand on the TLB. The reach of current TLBs is not sufficient to support this demand, the consequence is that an unacceptable fraction of total execution time will be spent servicing TLB misses. Cycle time and area constraints prohibit the brute force solution; scale the size of the TLB. Thus, the simulations in this project are performed to study the effectiveness of level two (L2) TLBs as a means of increasing overall TLB research. 16
PFC: Análisis TLB – Mónica Larruy Carrete 2. PROYECTO REALIZADO El mecanismo de traducción de direcciones en la paginación es bastante lento debido a que debe realizar dos accesos a memoria, uno al directorio y otro a la tabla de páginas para localizar la página. Además, requiere de un tercero para efectuar la lectura o escrituras precisas. Para acelerar el proceso de traducción, se introdujo dentro del propio chip una pequeña memoria caché ultrarrápida, denominada Translation Lookaside Buffer (TLB). Éste se encarga de almacenar la traducción de las direcciones virtuales a físicas, correspondientes a las últimas páginas que se han manejado. Con la paginación en marcha, la CPU consulta al TLB en cada acceso. Si la página referenciada se encuentra en ella, obtiene la dirección física de forma inmediata. Pero si no la encuentra, el mecanismo de paginación accede al directorio y a continuación a la tabla de páginas adecuada, cargando así el valor de la dirección física hallada en el TLB. A continuación, la CPU volverá a buscar en el TLB para efectuar el acceso. Para conseguir reducir el número de fallos en el acceso al TLB, y conseguir así una mejora cuantificable en esta caché, una opción pasaría por la implantación de un TLB de segundo nivel. De esta forma, se pretende que en el caso de acceder al de primer nivel y no encontrar la dirección deseada no se tenga que recurrir a la generación inmediata de una entrada en la tabla de paginación, con la intención de mapear la dirección virtual que faltaba, corregir así la dirección física, y reiniciar el programa. Sino que en su lugar, pasaría a consultar al TLB situado en el nivel inmediatamente superior (L2). Así pues, en caso de fallo en el primer nivel la responsabilidad pasaría a recaer sobre L2, ya que se espera de él que devuelva la dirección solicitada, aunque evidentemente ello sólo ocurrirá cuando contenga dicha información. Cabe destacar que las probabilidades de que la dirección deseada se encuentre en L2 es relativamente elevada en comparación con L1, ello es debido al tamaño empleado en este proyecto para cada uno de ellos. Concretamente, para obtener unos resultados deseados el tamaño L2 pasará a ser el doble que el de L1, por lo que dispondrá de más espacio para poder almacenar así más direcciones. El proyecto se encuentra estructurado principalmente en tres partes. En la primera de ellas, se realizará una introducción de conceptos que se consideran importantes por estar estrechamente ligados con el tema que se trata a lo largo del proyecto, así como del conjunto de herramientas utilizadas. 17
PFC: Análisis TLB – Mónica Larruy Carrete Un concepto muy importante debido a que se han realizado las simulaciones sobre esta arquitectura, son los procesadores superescalares. Éstos se caracterizan por conseguir ejecutar múltiples pipelines de forma simultánea, consiguiendo así ejecutar más instrucciones por segundo que un procesador escalar. Por otro lado, también destaca el apartado correspondiente al TLB, donde se efectuará una descripción de su integración/funcionamiento. En el siguiente bloque, se encontraría el estudio estático. En él se ha efectuado un análisis del comportamiento del TLB sin considerar un segundo nivel para diferentes posibles configuraciones. Para ello, los valores estudiados han sido el tiempo de acceso, el área y el consumo. La realización de esta parte, se ha efectuado variando el grado de asociatividad, el tamaño de línea, la escala de integración y el número de puertos de lectura y escritura. Por último, se ha efectuado el estudio dinámico. En éste se pretende estudiar el efecto de la implementación de un TLB en L2 comparada con una misma configuración en L1, pero con la diferencia de no contar con este nuevo nivel. Para su realización, se ha optado por estudiar los parámetros IPC, miss_rate y tiempo medio de acceso. 18
PFC: Análisis TLB – Mónica Larruy Carrete 3. INTRODUCCIÓN 3.1. SEGMENTACIÓN DE CAUCE Y PROCESADORES SEGMENTADOS 3.1.1. Conceptos teóricos En un procesador segmentado su microarquitectura se implementa a través de un circuito segmentado o cauce, es capaz de procesar varias instrucciones simultáneamente, aunque cada una de ellas puede encontrarse en una etapa diferente del cauce. El procesador es capaz de aprovechar el paralelismo entre instrucciones y aumentar su rendimiento (ejecutando más instrucciones por unidad de tiempo) sin tener que reducir necesariamente el tiempo de ejecución de cada instrucción. La segmentación de cauce (pipeling) es una técnica que permite aumentar el rendimiento del sistema. Consiste en identificar una serie de fases o pasos en el procesamiento de la tarea que realiza el sistema con el fin de rediseñarlo de forma que cada una de dichas fases se puedan implementar en una etapa que pueda trabajar independientemente de las otras. Con ello, el sistema podría estar procesando varias tareas al mismo tiempo, aunque cada una de ellas estaría en una etapa diferente, y por tanto en una fase diferente de su procesamiento. 3.1.2. Notas históricas El inicio del uso de la segmentación de cauce se puede ubicar en el IBM 709 que apareció en 1958 como una mejora del IBM 704. Con la misma frecuencia que el IBM 704, se conseguía un 60% más de prestaciones. En 1962 surgió el IBM 7094I. Entre las técnicas que incorporaba, una de las más destacadas es la inclusión del registro IBR (Instruction Backup Register), para almacenar la siguiente instrucción a ejecutar, permitiendo el solapamiento entre la ejecución de una instrucción y la captación de la siguiente. No es hasta el IBM 7030 Stretch donde se puede hablar de procesador de propósito general segmentado. Su microarquitectura estaba implementada a través de un cauce con cuatro etapas en la que se solapaban la captación, la decodificación y la ejecución. Después de utilizarse frecuentemente desde finales de los 50, la segmentación de cauce pasó a un plano secundario desde finales de los años 60 hasta finales de los 70, debido a que se hacía más 19
PFC: Análisis TLB – Mónica Larruy Carrete énfasis en las máquinas orientadas a simplificar el software. En los 80, con las arquitecturas RISC1 se vuelve a utilizar la segmentación de cauce, ya que RISC favorece el diseño sencillo para un cauce que puede integrarse en un microprocesador y facilitan el aprovechamiento eficiente del mismo. Desde mediados de los 80 los microprocesadores incorporan la segmentación de cauce en sus microarquitecturas de forma generalizada. En los años 90 se pasa a usar la segmentación incluso en los procesadores embebidos/integrados que necesitan prestaciones más elevadas. 3.1.3. Microprocesadores segmentados Si se analiza el ciclo de procesamiento de una instrucción, es posible distinguir diferentes etapas, tales como: la captación de la instrucción (FI), la decodificación de la misma (DI), el cálculo de los operandos (CO), la captación de operandos (FO), la ejecución de la instrucción (EI) y por último el almacenamiento del resultado (WO). Debido a que las instrucciones utilizan (idealmente) diferentes recursos en las distintas etapas de su ejecución, surge la idea de la segmentación. Un microprocesador segmentado es aquel que divide la ejecución de una instrucción en diversas etapas, de tal forma que, tan pronto como una instrucción finaliza la i‐ésima etapa, avanza a la etapa i+1, permitiendo que la instrucción ubicada en la etapa i‐1 alcance la etapa i. De esta manera se consigue iniciar en cada ciclo de reloj, la ejecución de una instrucción, ejecutando varias a la vez. Figura 1: Evolución de las instrucciones a través de las diferentes etapas de un microprocesador segmentado Pero, la diferente duración temporal de las etapas, la aparición de instrucciones de saltos condicionales, las llegadas de interrupciones, las disputas en el acceso a los recursos de hardware y la dependencia de datos entre las instrucciones en ejecución complican el diseño, debiéndose incluir la lógica necesaria para contrarrestar este tipo de conflictos. 1
RISC (Reduced Instruction Set Computer): Tipo de arquitecturas de computadoras que promueve conjuntos pequeños y simples de instrucciones que pueden tomar poco tiempo para ejecutarse. 20
PFC: Análisis TLB – Mónica Larruy Carrete 3.2. MICROPROCESADORES SUPERESCALARES En la mayoría de las aplicaciones, una gran parte de las operaciones se realiza con cantidades escalares, y el término superescalar, hace referencia a una máquina que ha sido diseñada para mejorar la velocidad de ejecución de las instrucciones escalares. En la implementación superescalar, las instrucciones comunes (aritmética entera y de punto flotante, cargas, almacenamientos y saltos condicionales) pueden iniciar su ejecución simultáneamente y ejecutarse de manera independiente siguiendo diferentes trayectos. La principal parte de los microprocesadores superescalares actuales disponen de un mecanismo de planificación dinámica de instrucciones. Es decir, las instrucciones no se ejecutan en el orden en que aparecen en el programa sino que el hardware decide en qué orden se ejecutan para un mayor rendimiento. De aquí que, también se les denomine microprocesadores con ejecución fuera de orden. La arquitectura del RISC se presta para usar técnicas superescalares, pero también se puede hacer en una CISC2. Para la realización de este proyecto, la arquitectura utilizada es concretamente una de tipo RISC. En apartados asociados al estudio dinámico se habrá detalladamente de ella. Los procesadores superescalares son procesadores segmentados, donde se introducen varios pipelines (trayectos segmentados) independientes, permitiendo procesar más de una instrucción por ciclo. Figura 2: Evolución de las instrucciones a través de las diferentes etapas de un microprocesador superescalar con dos trayectos segmentados de seis etapas cada uno Una de las maneras de aumentar las prestaciones de los procesadores segmentados sería la de utilizar varias unidades funcionales que pudiesen trabajar simultáneamente con diferentes instrucciones. CISC (Complex Instruction Set Computer) es un modelo de arquitectura de computadores. Los microprocesadores CISC 2
tienen un conjunto de instrucciones que se caracteriza por ser muy amplio y permitir operaciones complejas entre operandos situados en la memoria o en los registros internos, en contraposición a la arquitectura RISC. 21
PFC: Análisis TLB – Mónica Larruy Carrete Si bien con esta mejora se puede mejorar el rendimiento de un procesador segmentado, no permite sobrepasar el límite máximo de una instrucción terminada por cada ciclo. Por tanto, la idea que surge en los procesadores superescalares es la de conseguir que puedan procesar a la vez varias instrucciones en todas las etapas. Una primera forma de mejorar el número de instrucciones procesadas por ciclo consiste en organizar el procesador en varios cauces que funcionen en paralelo y de forma casi independiente. Figura 3: Microarquitectura para un procesador segmentado capaz de procesar dos instrucciones por ciclo Sin embargo, la forma usual de organizar la microarquitectura en los procesadores superescalares es la que se muestra a continuación: Figura 4: Microarquitectura más usual en procesadores superescalares Aquí, en cada una de las etapas es capaz de procesar varias instrucciones por ciclo. Entre cada una de las diferentes etapas están presentes diferentes estructuras de almacenamiento (buffers, 22
PFC: Análisis TLB – Mónica Larruy Carrete cachés, etc.), que guardan la informació de la instrucción procesada en la etapa anterior, hasta que les toque ser procesadas en la siguiente etapa. ETAPAS: 1) El microprocesador dispone de una memoria caché de instrucciones desde la cual, en cada ciclo, se captan varias instrucciones a la vez del programa a ejecutar (etapa de captación de instrucciones (IF)), que está compuesto por una secuencia lineal de instrucciones. Además, se incluye en el proceso de captación, una técnica de predicción de saltos para lograr una mayor fluidez en la captación de las instrucciones. 2) Las instrucciones pasan, en el orden captado, a una cola donde se introducen de forma ordenada en la etapa de decodificación (ID), tantas como sea capaz de codificar por ciclo. A la espera de que los operandos y unidades funcionales que necesitan estén disponibles, se almacenan en estructuras (ventana de instrucciones, estaciones de reserva, buffer de renombramiento, etc.) y se examinan las dependencias de datos entre las instrucciones para encontrar aquellas que sean independientes y se puedan ejecutar en paralelo. 3) A continuación, se escogerá las que pueden pasar a ejecutarse (etapa de emisión (issue)). En esta etapa se determinará qué instrucciones de las que se encuentran dentro de unos ciertos buffers pueden pasar a ejecutarse y a qué unidad funcional. El número máximo de unidades de procesamiento indicará el número máximo de instrucciones que podrán ejecutarse simultáneamente. 4) La etapa de ejecución está implementada por varias unidades funcionales, para aumentar las prestaciones, que realizan las operaciones de codificación de las instrucciones (operaciones aritméticas, escritura o lectura de memoria, unidad de procesamiento de saltos). 5) Finalmente, se pasaría a la etapa de escritura, que almacenaría los resultados en el banco de registros del procesador. En un procesador superescalar las instrucciones se captan y se decodifican en el orden en que aparecen en el programa. Sin embargo, puede ocurrir que el orden en que las instrucciones se ejecutan y el orden en que cambian los registros y la memoria pueden no coincidir con el orden de las instrucciones en el código. El motivo de no respetar dicho orden se debe al posible aprovechamiento del paralelismo entre instrucciones y el paralelismo disponible en el procesador. Así pues, un procesador superescalar debe ser capaz de identificar el paralelismo entre instrucciones (ILP) existente en el código y permitir que los recursos se usen lo más eficazmente en la ejecución paralela de instrucciones. 23
PFC: Análisis TLB – Mónica Larruy Carrete 3.3. LA MEMORIA Después del procesador, la memoria es el componente más importante en un ordenador. De manera ideal, una memoria deberá ser extremadamente rápida, con tamaño de sobra y con coste insignificante. Pero ello es idealmente, ya que ninguna tecnología actual satisface todos estos requisitos.
Figura 5: Jerarquía usual de memoria Los programas y datos necesitan estar en la memoria principal para ser ejecutados, o para poder ser referenciados. Los programas o datos que no se necesitan de inmediato pueden guardarse en la memoria secundaria hasta que se necesiten, y en ese momento se transfieren a la memoria principal para ser ejecutados o referenciados. Los soportes de memoria secundaria, como por ejemplo discos, son en general menos caros que la memoria principal, y su capacidad es mucho mayor. Normalmente, es mucho más rápido el acceso a la memoria principal que a la secundaria. La jerarquía de memoria se divide en: ‐
Registros internos de la CPU. Éstos son tan rápidos como ella. Por supuesto el acceso a ellos no implica retrasos. Los programas deben administrarlos (decidir qué colocar en ellos). ‐
Memoria caché. CPU
Transferencia de palabras
Caché
Transferencia de bloques
Memoria principal
Figura 6: Caché y memoria principal Es un conjunto de datos duplicados de otros originales, con la propiedad de que los datos originales son costosos de acceder, normalmente en tiempo, respecto a la copia en la caché. Cuando se accede por primera vez a un dato, se hace una copia en la caché; los 24
PFC: Análisis TLB – Mónica Larruy Carrete accesos siguientes se realizan a dicha copia, haciendo que el tiempo de acceso medio al dato sea menor. La memoria caché está estructurada por celdas, donde cada celda almacena un byte. La entidad básica de almacenamiento la conforman las filas, llamados también líneas de caché. Por ejemplo, una caché L2 de 512 KB se distribuye en 16.384 filas y 32 columnas. Cuando se copia o se escribe información de la RAM por cada movimiento siempre cubre una línea de caché. La memoria caché tiene incorporado un espacio de almacenamiento llamado Tag RAM, que indica a qué porción de la RAM se halla asociada cada línea de caché, es decir, traduce una dirección de RAM en una línea de caché concreta. Cabe destacar, que actualmente la memoria caché cuenta con uno o más niveles: L1 (caché de nivel 1) y, generalmente, L2 (caché de nivel 2). ‐
Memoria principal. La memoria principal también se conoce como RAM (Random Access Memory). Contiene de forma temporal el programa, los datos y los resultados que están siendo usados por el usuario. En general es volátil, pierde su contenido cuando se apaga el computador, a excepción de la CMOS RAM. EL contenido de las memorias no es otra cosa que bits (binary digits), que se corresponden con dos estados lógicos: el 0 (cero) sin carga eléctrica y el 1 con carga eléctrica. A cada uno de estos estados se le llama bit. El bit es la unidad mínima de almacenamiento de datos. ‐
Disco magnético (disco duro). El almacenamiento en disco es dos órdenes de magnitud más barato por bit que la RAM y también suele ser dos órdenes de magnitud más grande. El único problema es que el tiempo necesario para tener acceso aleatorio a los datos que contiene es casi tres órdenes de magnitud superior. 25
PFC: Análisis TLB – Mónica Larruy Carrete 3.4. Gestión de la memoria En el caso de la memoria, el sistema operativo (SO), con el apoyo del hardware de gestión de memoria del procesador, debe repartir el almacenamiento existente proporcionando un espacio de memoria independiente para cada proceso y evitando la posible interferencia voluntaria o involuntaria de cualquier otro proceso. 3.4.1. Requisitos de la gestión de memoria Sea cual sea la política de gestión de memoria empleada en un determinado sistema, se pueden destacar las siguientes características como objetivos deseables del sistema de gestión de memoria: ‐
Reubicación: En un sistema multiprogramado la memoria se encuentra compartida por varios procesos, por lo tanto, los procesos deben ser cargados y descargados de memoria. ‐
Protección: En un sistema con multiprogramación es necesario proteger al sistema operativo y a los otros procesos de posibles accesos que se puedan realizar a sus espacios de direcciones. ‐
Compartición: En ciertas situaciones, bajo la supervisión y control del sistema operativo, puede ser provechoso que los procesos puedan compartir memoria. ‐
Organización lógica: Tanto la memoria principal como la secundaria presentan una organización física similar, como un espacio de direcciones lineal y unidimensional. Debe existir una cierta correspondencia entre el SO y el hardware al tratar los datos y los programas de los usuarios de acuerdo a la estructura lógica que ellos presenten. ‐
Organización física: Debe ser parte de la gestión de memoria, la organización del flujo de información entre la memoria principal y la memoria secundaria. 26
PFC: Análisis TLB – Mónica Larruy Carrete 3.4.2. Memoria principal o real 3.4.2.1.
Asignación contigua En un esquema de asignación de memoria contigua un proceso se ubica en su totalidad en posiciones consecutivas de memoria. Generalmente se divide la memoria en dos particiones, una para el SO residente y otra para los procesos de usuario. Particiones estáticas El esquema más sencillo de gestión de la memoria disponible es dividirlo en regiones con límites fijos. Existen dos posibilidades: 1) Particiones estáticas de igual tamaño: ‐
Cualquier proceso cuyo tamaño sea menor o igual que el tamaño de la partición puede cargarse en cualquier partición libre. ‐
Si todas las particiones están ocupadas, el SO puede sacar un proceso de una partición. ‐
Un programa puede que no se ajuste a una partición. El programador debe diseñar el programa mediante superposiciones. ‐
No requieren el uso de memoria virtual. ‐
Es una política de gestión de memoria que prácticamente ha quedado obsoleta. Ej: SO IBM OS/360 ‐1964. 2) Particiones estáticas de diferente tamaño: ‐
Pueden asignar cada proceso a la partición más pequeña en la que quepa. ‐
Hace falta una cola para cada partición. ‐
Los procesos están asignados de forma que se minimiza la memoria desaprovechada dentro de cada partición. En ambos casos, surgen dos problemas: ‐
El programa puede ser mayor que los espacios de la partición => diseño del programa para que sólo una parte del programa esté en la memoria principal en cada instante => Superposición. ‐
Uso de la memoria principal ineficiente, cualquier programa aunque sea pequeño ocupará toda una partición => desaprovechamiento de memoria => Fragmentación. 27
PFC: Análisis TLB – Mónica Larruy Carrete Particiones dinámicas Con esta técnica, las particiones son variables en número y longitud. Cuando se carga un proceso en la memoria principal, se le asigna exactamente tanta memoria como necesita y no más. Finalmente, hay varios huecos en la memoria. Este fenómeno se denomina fragmentación externa. Ante este fenómeno, se deberá usar la compactación para desplazar los procesos que estén contiguos, de forma que toda la memoria libre quede junta en un bloque. 3.4.2.2.
Asignación no contigua En la asignación no contigua, un programa se divide en varios bloques o segmentos que pueden almacenarse en direcciones que no tienen que ser necesariamente adyacentes, por lo que es más compleja pero más eficiente que la asignación contigua. Para este tipo de asignación se recurre, por ejemplo, a la paginación. La cual se pasa a explicar en el siguiente apartado. 3.4.3. Paginación simple 3.4.3.1.
Fundamentos 28
PFC: Análisis TLB – Mónica Larruy Carrete Para efectuar la lectura de una palabra de la memoria, se debe realizar la traducción mediante la tabla de páginas de una dirección virtual (DV) (o lógica) (#página:desplazamiento) a una dirección física (#marco:desplazamiento). Debido a que la tabla de páginas es de longitud variable, según el tamaño del proceso, no se puede suponer que quepa en los registros. En su lugar, debe estar en la memoria principal para ser accesible. 3.4.3.2.
Paginación La paginación es un esquema de gestión de memoria que suprime el requisito de asignación contigua de memoria física. En este tipo de esquema, se mantiene la correspondencia de direcciones para conservar la ilusión de contigüidad del espacio de direcciones virtuales de un proceso a pesar de su ubicación discontinua en memoria física. La paginación considera el espacio de direcciones lógicas (o también conocidas como virtuales) de cada proceso como un conjunto de bloques de tamaño fijo de igual tamaño llamados páginas3. Cada dirección lógica manejada para un proceso estará conformada por un par de valores (#página:desplazamiento). La memoria física se administra implementando bloques de tamaño fijo denominados marcos (frames). Por lo general el tamaño designado para los marcos y páginas es pequeño. El SO internamente mantiene una tabla de páginas (TP) donde relaciona cada página cargada en memoria principal con el frame que la contenga. Utilizando el número de página el sistema recorrerá toda la tabla de páginas hasta localizarla, sumará el desplazamiento a la dirección de carga y obtendrá la dirección real. Cada programa se subdivide en páginas, que se cargan en frames libres que no tienen porque ser seguidos. El sistema analizará cada nuevo trabajo para conocer el número de página que ocupa y buscará en la lista de frames libres un número igual de frames; si encuentra suficientes cargará en ellas las páginas del programa y construirá la tabla de páginas. Figura 7: Esquema paginación 3
Las páginas sirven como unidad de almacenamiento de información y de transferencia entre memoria principal y memoria auxiliar o secundaria. Las páginas de un programa necesitan estar contiguamente en memoria. Los mecanismos de paginación permiten la correspondencia correcta entre las direcciones virtuales (dadas por los programas) y las direcciones reales de la memoria que se referencien. 29
PFC: Análisis TLB – Mónica Larruy Carrete A continuación, se puede observvar la forma de una dirección lógica: Figura 8: Estructura dirección lógica Tanto el espacio lógico como fíísico está dividido en páginas de mismo tamañ
ño y la traducción consiste simplemente en enconttrar la correspondencia entre página y marco. Nótese que consecuencia de ello es que todas las páginas son del mismo tamaño (2k), y además todas las páginas empiezan en u
una posición de memoria múltiplo de dicho tam
maño (frontera de página). Las páginas se transfieren del almacenamiento secundario al primario en bloques b
llamados marcos. Éstos tienen el mism
mo tamaño que las páginas, comienzan en direcciones del almacenamiento real que son múltiplos m
enteros del tamaño fijo de la página y y podrá colocarse una nueva página dentro de cualquier marco de página o celda de página disponible. nación, la memoria principal se divide en pequ
ueños marcos del Resumiendo, mediante la pagin
mismo tamaño. Cada proceso see divide en páginas del tamaño del marco (los prrocesos pequeños necesitarán pocas páginas, mieentras que los procesos grandes necesitarán más). Cuando se introduce un proceso en la mem
moria, se cargan todas sus páginas en los marcos libres y se rellena su tabla de páginas. Figura 9: Ejemplo de ttraducción de direcciones mediante paginación La traducción se lleva a cabo mediante m
una TP, la cual es indexada por el núm
mero de página y proporciona el número de marco
o. 30
PFC: Análisis TLB – Mónica Larruy Carrete Si se accede a una página no presente, la MMU4 (Memory Management Unit) generará un fallo de página. 3.4.3.3.
Tamaño de la página La decisión del tamaño de página implica una solución de compromiso entre aquellos factores que favorecen una página mayor frente a los que favorecen una página más pequeña. ‐
Ventajas de un tamaño de página grande: ∙ Menos páginas Æ Tabla de páginas más pequeña Æ Ahorro de memoria. ∙ Transferencia más eficiente. ‐
Ventajas de un tamaño de página pequeño: ∙ Mejor aprovechamiento de la memoria por una menor fragmentación de la misma. ∙ Procesos pequeños: una página grande implica un tiempo mayor para invocar el proceso. La tendencia es en general hacia páginas grandes, ya que la penalidad por traer una página es muy grande y se justifica más si se traen más datos. La mayoría de las máquinas tienen páginas de 4K, incrementándose para nuevos modelos. A la hora de efectuar la elección del tamaño de la página, se deben tener en cuenta diversos factores: ‐
Tamaño de las unidades de transferencia con memoria secundaria. ‐
Es conveniente que el tamaño de la página coincida con un número entero de sectores. De esta forma se optimizan tanto el uso como el tiempo de acceso a memoria secundaria. ‐
Tamaño de la tabla de páginas Ya que si el tamaño de la página aumenta, el tamaño de la tabla de páginas (TP) disminuye. ‐
Tamaño medio de las entidades lógicas del programa Si el tamaño de la página es similar al tamaño medio de las entidades lógicas del programa, se aprovecha al máximo la localidad espacial. ‐
Fragmentación interna. MMU: es un dispositivo hardware, responsable del manejo de los accesos a la memoria por parte de la Unidad de 4
Procesamiento Central (CPU). Entre las funciones de este dispositivo se encuentran la traducción de las direcciones lógicas (o virtuales) a direcciones físicas (o reales), la protección de la memoria, el control de caché. 31
PFC: Análisis TLB – Mónica Larruy Carrete Computador
IBM360/67
MC68020 MIPS R2000/3000
Alpha 21064
Pentium Tamaño de página
4 KB
256 bytes a 32 KB
4 KB
8 KB
4 KB o 4 MB
Tabla 1: Ejemplos de tamaños de páginas El tamaño de la página al igual que el del marco está definido por el hardware y suele ser potencia de 2 que varía entre 512 bytes y 16 megabytes por página dependiendo de la arquitectura del computador. La selección de una potencia de dos para el tamaño de las páginas facilita mucho la traducción de una dirección lógica a un número de página y desplazamiento de página. 3.4.3.4.
Implementación de la tabla de páginas (TP) La implementación de la tabla de páginas se puede llevar a cabo mediante alguna de las siguientes opciones: Ventaja Implementación hardware
Implementación en memoria principal
Se obtiene una alta velocidad en La tabla de páginas puede crece según se hardware quiera Desventaja Resulta problemática cuando la La velocidad de acceso a memoria es tabla de páginas debe ser grande relativamente baja, dado que cada referencia a memoria involucra dos accesos Tabla 2: Posibles implementaciones de la TP 3.4.4. Segmentación simple Otro modo de subdividir un programa es la segmentación. En este caso, el programa junto con sus datos se divide en un conjunto de segmentos. No es necesario que todos los segmentos de todos los programas tengan la misma longitud, aunque existe una longitud máxima de segmento. El tamaño de cada segmento será el requerido según la petición, por ejemplo el tamaño del proceso a cargar. 32
PFC: Análisis TLB – Mónica Larruy Carrete na dirección lógica segmentada consta de dos p
partes, un número Al igual que en la paginación, un
de segmento y un desplazamientto. n tienen por qué Con segmentación, un programa puede ocupar más de una partición y éstas no estar contiguas. nsparente al programador, la segmentación suele s
ser visible. Si bien la paginación es tran
Generalmente, se asignan los pro
ogramas y los datos a diferentes segmentos. Una consecuencia del tamaño desigual de los segmentos es que no hay unaa correspondencia simple entre las direcciones lógiicas y las direcciones físicas. Análogamente a la paginación, en la segmentación se utilizará una taabla de segmentos (TS) para cada proceso y una lista de bloques libres en la memoria principal. Cada entrada de la TS contiene lla dirección de inicio del segmento en la memorria principal. Dicha entrada también debe proporcionar la longitud del segmento, para asegurarr que no se usen direcciones no válidas. Cuando sse pasa a ejecutar un proceso, se carga la dirección de su TS en un registro especial llamado RIED (Registro Identificador del Espacio de Direccion
namiento), el cual permite agilizar el acceso a dichaa dirección. Resumiendo, con segmentación simple un proceso se divide en varios segmenttos que no tienen por qué ser del mismo tamaño. Cuando un proceso se introduce en la memoriaa, se cargan todos memoria libres y se rellena la tabla de segmentos.. sus segmentos en regiones de m
3.4.4.1.
Traducción de diirecciones segmentadas Figura 10: Traducción de direcciones mediante segmentación Una dirección lógica consta de d
dos partes: un número de segmento y un desplaazamiento dentro de ese segmento. El número de ssegmento se utiliza como un índice en la TS. Cada entrada de la TS tiene una base de segmento y un
n límite/tamaño t. El desplazamiento d de la direección lógica tiene que estar comprendido entre 0 y el límite de segmento. En caso contrario
o se produce una 33
PFC: Análisis TLB – Mónica Larruy Carrete excepción al sistema operativo (tentativa de direccionamiento lógico máss allá del fin de segmento). Si este desplazamiento es legal, se añade a la base para producir la dirección de la nte una matriz de tabla deseada en la memoria fíísica. La tabla de segmentos es así esencialmen
pares registros base/límite. La traducción, al igual que en
n la paginación, se lleva a cabo por hardwa
are en la MMU. Comprobaciones que se efectúan: 1. ¿Está definido el desccriptor de segmento? Si no es así, error de acceeso: segmento no validado. e
de acceso: 2. ¿Está el desplazamieento dentro del segmento? Si no es así, error desplazamiento no váliido. 3.4.4.2.
Protección on los segmentos. Una ventaja importante de la seegmentación es la asociación de la protección co
Puesto que los segmentos reprresentan una porción del programa, es probab
ble que todas las entradas en el segmento se utiliccen de la misma manera. De ahí que se tengan algunos segmentos que son instrucciones, mientrras que otros son datos. En una arquitectu
ura moderna las instrucciones son no automodificables, de modo que los segmentos de instrrucciones pueden b de protección definirse como de sólo lectura o sólo ejecución. El hardware verificará los bits asociados a cada entrada en la tabla de segmentos para impedir accesos ilegaless a memoria, tales s
de sólo como tentativas de escribir en un segmento de sólo lectura o de utilizar un segmento do una tabla en un segmento propio, el ha
ardware verificará ejecución como datos. Situand
automáticamente que toda indeexación en la tabla es legal, y no sobrepasa los lím
mites de la misma. Así, muchos errores frecuentess en programas serán detectados por hardwa
are antes de que puedan ocasionar un daño serio.. Figu
ura 11: Esquema protección en segmentación 34
PFC: Análisis TLB – Mónica Larruy Carrete Se determina si es válido el acceso o no en función de los bits de protección y del tipo de acceso. Algunos procesadores se ahorran bits de protección haciendo que algunas opciones sean implícitas. Por ejemplo, en la familia 80286: ‐ Bit E: Tipo de segmento. 0: datos (siempre se pueden leer, nunca se pueden ejecutar). 1: código (siempre se pueden ejecutar, nunca se pueden modificar). ‐ R/W: En segmentos de código, si R/W= 1 el segmento se puede leer. En segmentos de datos, si R/W = 1 el segmento se puede modificar. 3.4.4.3.
Fragmentación El SO tiene que encontrar y asignar memoria para todos los segmentos de un programa. Esta situación es similar a la paginación, excepto en el hecho de que los segmentos son de longitud variable; las páginas son todas del mismo tamaño. La segmentación puede ocasionar entonces fragmentación externa, cuando todos los bloques libres de memoria son demasiado pequeños para acomodar a un segmento. En este caso, el proceso puede simplemente verse obligado a esperar hasta que haya disponible más memoria (o al menos huecos más grandes), o puede utilizarse la compactación para crear huecos mayores. Puesto que la segmentación es por naturaleza un algoritmo de reubicación dinámica, se puede compactar la memoria siempre que se desee. ¿En qué medida es mala la fragmentación externa en un esquema de segmentación? La respuesta a esta pregunta depende principalmente del tamaño medio de segmento. En un extremo, se podría definir cada proceso como un segmento; este esquema es el de las particiones dinámicas. En el otro extremo, cada palabra podría situarse en su propio segmento y reubicarse por separado. Esta disposición elimina la fragmentación externa. Si el tamaño medio de segmento es pequeño, la fragmentación externa también será pequeña. Puesto que los segmentos individuales son más pequeños que el proceso en conjunto, es más probable que encajen en los bloques de memoria disponibles. 35
PFC: Análisis TLB – Mónica Larruy Carrete 3.4.5. Paginación vs Segmentación Es evidente, tras lo comentado en apartados anteriores, que existen diferencias notables entre los sistemas de paginación y los basados en segmentación, ya que en ambos surgen grandes ventajas e inconvenientes. Muestra de ello es que, diversos fabricantes utilizan diferentes políticas: ‐
Motorola 6800 Æ Paginación (MAC antes de PowerPC). ‐
Intel 80x86 Æ Segmentación (PC). 3.4.5.1.
Fragmentación La fragmentación es generada cuando durante el reemplazo de procesos quedan huecos entre dos o más procesos de manera no contigua y cada hueco no es capaz de soportar ningún proceso de la lista de espera. En ambos casos, surge fragmentación. Pero como se verá a continuación, el tipo de fragmentación es diferente: 1) Fragmentación interna (paginación) ‐
Se debe a la diferencia de tamaño entre la partición de memoria y el objeto residente dentro de ella. ‐
Se produce siempre que se trabaje con bloques de memoria de tamaño fijo. ‐
Si el tamaño del objeto no coincide con el de partición, queda una zona que no se puede aprovechar. Figura 12: Fragmentación interna La fragmentación interna es causada por el hecho de que difícilmente un programa ocupe un número entero de páginas, entonces parte de la última es desaprovechada. 36
PFC: Análisis TLB – Mónica Larruy Carrete 2) Fragmentación externa (segmentación) Surge como resultado del desaprovechamiento de huecos de memoria entre segmentos. Figura 13: Fragmentación externa La fragmentación externa se puede reducir mediante la compactación para colocar toda la memoria libre en un único gran bloque, pero ello sólo es posible si la relocalización es dinámica y se hace en tiempo de ejecución.
3.4.5.2.
Ejemplo de traducción de dirección lógica a física Los primeros esquemas de organización de la memoria principal utilizaban las direcciones lógicas directamente como direcciones físicas. Esquemas más evolucionados de organización de memoria principal distinguen entre estos dos espacios de direcciones. En estos casos, la traducción de una dirección lógica a una física se realiza mediante un mecanismo hardware llamado Unidad de Gestión de Memoria (MMU). Paginación Ejemplo: Dirección relativa 1502 en binario 0000010111011110 Dirección lógica de 16 bits
Desplazamiento de 10 bits
Nº de página
0
0
0
0
0
1
0
0
000101
1
2
000110
1
1
1
0
1
1
1
1
0
011001
Tabla de páginas
0
0
0
1
1
0
0
1
1
1
0
1
1
1
1
Dirección lógica de 16 bits
0
Figura 14: Ejemplo de traducción de dirección lógica a física mediante paginación 37
PFC: Análisis TLB – Mónica Larruy Carrete En la figura 14, se usa la dirección lógica 0000010111011110, que corresponde con el número de página 1 y el desplazamiento 478. Considerando que la página está en el marco de memoria principal 6=000110, la dirección física estaría formada por el marco 6 y el desplazamiento 478 = 0001100111011110. Segmentación Figura 15: Ejemplo de traducción de dirección lógica a física mediante segmentación En la figura 15, se utiliza la dirección lógica 0001001011110000, que pertenece al número de segmento 1 y desplazamiento 752. Suponiendo que dicho segmento se encuentra en la memoria principal y comienza en la dirección física 0010000000100000. Entonces la dirección física que se obtendrá será 0010000000100000+0010000000100000=0010001100010000. 3.4.5.3.
Comparativa general ¿Necesita el programador saber si está utilizando esta técnica? ¿Cuántos espacios lineales de direcciones existen? ¿Puede el espacio total de direcciones exceder el tamaño de la memoria física? ¿Pueden distinguirse los procedimientos y los datos, además de protegerse en forma independiente? ¿Pueden adecuarse con facilidad las tablas con tamaños fluctuantes? ¿Se facilita el uso de procedimientos compartidos entre los usuarios? Paginación
Sí 1 Segmentación No Muchos Sí Sí No Sí No Sí No Sí 38
PFC: Análisis TLB – Mónica Larruy Carrete Reemplazo de un bloque Uso ineficiente de memoria Tráfico de disco eficiente ¿Para qué se inventó esta técnica? Trivial (todos los bloques tienen el mismo tamaño) Fragmentación interna Sí (ajusta tamaño de página para equilibra tiempo de acceso y tiempo de transferencia) Para obtener un gran espacio lineal de direcciones sin tener que adquirir más memoria física Difícil (debe encontrar una parte no utilizada en memoria principal de tamaño variable y contigua) Fragmentación externa No siempre (pequeños segmentos pueden transferir sólo unos pocos bytes) Para permitir que los programas y datos fueran separados en espacios independientes de direcciones y poder proporcionar la protección y uso de objetos compartidos Tabla 3: Comparativa entre paginación y segmentación 3.4.5.4.
Paginación: Ventajas e Inconvenientes Ventajas ‐ Es posible comenzar a ejecutar un programa, cargando sólo una parte del mismo en memoria, y el resto se cargará bajo solicitud. ‐ No es necesario que las páginas estén contiguas en memoria, por lo que no se necesitan procesos de compactación cuando existan marcos de paginas libres dispersos en la memoria. ‐ Es fácil controlar todas las páginas, ya que tienen el mismo tamaño. ‐ El mecanismo de traducción de direcciones permite separar los conceptos de espacio de direcciones y espacios de memoria. Todo el mecanismo es transparente al usuario. ‐ Se libera al programador de la restricción de programar para un tamaño físico de memoria, con lo que se aumenta su productividad. Se puede programar en función de una memoria mucho más grande a la existente. ‐ Al no necesitarse cargar un programa completo en memoria para su ejecución, se puede aumentar el número de programas multiprogramándose. ‐ Se elimina el problema de la fragmentación externa. Inconvenientes ‐ El coste de hardware y software se incrementa, por la nueva información que debe manejarse y el mecanismo de traducción de direcciones necesario. Se consume muchos más recursos de memoria. 39
PFC: Análisis TLB – Mónica Larruy Carrete ‐ Se deben reservar áreas de memoria para las tablas de páginas de los procesos. Al no ser fija el tamaño de éstas, se crea un problema semejante al de los programas (como asignar un tamaño óptimo sin desperdicio de memoria u ovearhead del procesador). ‐ Aparece el problema de fragmentación interna. Así, si se requieren 5K para un programa, pero las paginas son de 4K, deberán asignárseles 2 páginas (8k), con lo que quedan 3K sin utilizar. La suma de los espacios libres dejados de esta forma puede ser mayor que el de varias páginas, pero no podrán ser utilizados. Debe asignarse un tamaño promedio a las páginas, evitando que si son muy pequeñas, se necesiten tablas de páginas muy grandes, y si son muy grandes, se incremente el grado de fragmentación interna. 3.4.5.5.
Segmentación: Ventajas e Inconvenientes Ventajas ‐
El programador puede conocer las unidades lógicas de su programa, dándoles un tratamiento particular. ‐
Es posible compilar módulos separados como segmentos. ‐
Debido a que es posible separar los módulos se hace más fácil la modificación de los mismos. Y cambios dentro de un módulo no afecta al resto de los módulos. ‐
Es fácil el compartir segmentos. ‐
Es posible que los segmentos crezcan dinámicamente según las necesidades del programa en ejecución. ‐
Existe la posibilidad de definir segmentos que aún no existen. Así, no se asignará memoria, sino a partir del momento que sea necesario hacer uso del segmento. Un ejemplo de esto, serían los arreglos cuya dimensión no se conoce hasta que no se comienza a ejecutar el programa. En algunos casos, incluso podría retardar la asignación de memoria hasta el momento en el cual se referencia el dato por primera vez. Inconvenientes ‐
Hay un incremento en los costes de hardware y de software para llevar a cabo la implantación, así como un mayor consumo de recursos: memoria, tiempo de CPU, etc. ‐
Debido a que los segmentos tienen un tamaño variable se pueden presentar problemas de fragmentación externa, lo que puede suponer un plan de reubicación de segmentos en memoria principal. 40
PFC: Análisis TLB – Mónica Larruy Carrete ‐
Se complica el manejo de memoria virtual, ya que los discos almacenan la información en bloques de tamaños fijos, mientras los segmentos son de tamaño variable. Esto hace necesaria la existencia de mecanismos más costosos que los existentes para paginación. ‐
Al permitir que los segmentos varíen de tamaño, pueden ser necesarios planes de reubicación a nivel de disco. ‐
No se puede garantizar, que al salir un segmento de la memoria, éste pueda ser traído fácilmente de nuevo, ya que será necesario encontrar nuevamente un área de memoria libre ajustada a su tamaño. ‐
La compartición de segmentos permite ahorrar memoria, pero requiere de mecanismos adicionales da hardware y software. Las desventajas mencionadas (tanto para paginación como para segmentación) tratan de ser minimizadas, bajo la técnica conocida como paginación y segmentación combinadas. 3.4.6. Memoria virtual En un sistema la memoria está organizada como una jerarquía de niveles de almacenamiento, entre los que se mueve la información dependiendo de la necesidad de la misma en un determinado instante. La técnica de memoria virtual se ocupa de la transferencia de información entre la memoria principal y la secundaria. La memoria secundaria está normalmente soportada en un disco (o partición). La memoria virtual es una técnica para proporcionar la simulación de un espacio de memoria mucho mayor que la memoria física de una máquina. Esta "ilusión" permite que los programas se efectúen sin tener en cuenta el tamaño exacto de la memoria física. La ilusión de la memoria virtual está soportada por el mecanismo de traducción de memoria, junto con una gran cantidad de almacenamiento rápido en disco duro. Así en cualquier momento el espacio de direcciones virtuales hace un seguimiento de tal forma que una pequeña parte de él, está en memoria real y el resto almacenado en el disco, y puede ser referenciado fácilmente. La memoria virtual ha llegado a ser un componente esencial de la mayoría de los SO actuales. Y como en un instante dado, en la memoria sólo se tienen unos pocos fragmentos de un proceso dado, se pueden mantener más procesos en la memoria. Es más, se ahorra tiempo, porque los 41
PFC: Análisis TLB – Mónica Larruy Carrete fragmentos que no se usan no se cargan ni se descargan de la memoria. Sin embargo, el SO debe saber cómo gestionar este esquema. La memoria virtual también simplifica la carga del programa para su ejecución llamado reubicación, este procedimiento permite que el mismo programa se ejecute en cualquier posición de la memoria física. En un estado estable, prácticamente toda la memoria principal estará ocupada con fragmentos de procesos, por lo que el procesador y el SO tendrán acceso directo a la mayor cantidad de procesos posibles, y cuando el SO traiga a la memoria un fragmento, deberá expulsar otro. Si expulsa un fragmento justo antes de ser usado, tendrá que traer de nuevo el fragmento de manera casi inmediata. Demasiados intercambios de fragmentos conducen a lo que se conoce como hiperpaginación, donde el procesador pasa más tiempo intercambiando fragmentos que ejecutando instrucciones de usuario. Para evitarlo el SO intenta adivinar, en función de la historia reciente, qué fragmentos se usarán con menor probabilidad en un futuro próximo. Los argumentos anteriores se basan en el principio de cercanía o principio de localidad, que afirma que las referencias a los datos y el programa dentro de un proceso tienden a agruparse. Dicha propiedad permite que un proceso genere muy pocos fallos aunque tenga en memoria principal sólo una parte de su imagen de memoria. Ya que, sería posible hacer predicciones inteligentes sobre qué fragmentos de un proceso se necesitarán en un futuro cercano y así evitar la hiperpaginación. Este principio consiste en el agrupamiento de las lecturas de memoria por medio de la unidad central de procesamiento. Las mismas, ya sean para instrucciones o para leer datos, se mantienen por lo general dentro de grupos de direcciones relativamente cercanas entre sí. El principio de cercanía sugiere que los esquemas de memoria virtual pueden funcionar eficazmente. Justo después de obtener la dirección física y antes de consultar el dato en memoria principal se busca en memoria caché, si está entre los datos recientemente usados la búsqueda tendrá éxito, pero si falla, la memoria virtual consulta memoria principal, o en el peor de los casos se consulta de disco (swapping). Cuando se usa memoria virtual, o cuando una dirección es leída o escrita por la CPU, una parte del hardware dentro de la computadora traduce las direcciones de memoria generadas por el software (direcciones virtuales) en: ‐
la dirección real de memoria (la dirección de memoria física), o 42
PFC: Análisis TLB – Mónica Larruy Carrete ‐
una indicación de que la dirección de memoria deseada no se encuentra en memoria principal (llamada excepción de memoria virtual). En el primer caso, la referencia a la memoria es completada, como si la memoria virtual no hubiera estado involucrada: el software accede donde debía y sigue ejecutando normalmente. En el segundo caso, el SO es invocado para manejar la situación y permitir que el programa siga ejecutando o aborte según sea el caso. 3.4.6.1.
Objetivos de la memoria virtual ‐
Permite disponer de un espacio de direcciones superior al real. ƒ
Los programas pueden tener un tamaño mayor que el espacio disponible en memoria física. ƒ
‐
La gestión de la memoria virtual es transparente al programador/usuario. Permite compartir eficientemente la memoria entre múltiples procesos garantizando protección. ƒ
La memoria principal necesita sólo las partes activas de los programas. Ello permite compartir eficientemente el procesador así como la memoria principal. Proporcionando los mecanismos de protección necesarios. ƒ
La memoria física se reparte entre los procesos que se ejecutan en la máquina. ƒ
Cada proceso puede tener su propio espacio de direcciones virtuales independiente del resto de procesos. La memoria virtual se basa en dos técnicas para lograr su propósito: la paginación y la segmentación. 3.4.6.2.
Paginación La memoria virtual se construye generalmente sobre un esquema de paginación, ya sea paginación pura o segmentación paginada. Por tanto, las unidades de información que se transfieren entre la memoria principal y la secundaria son páginas. Tal como se indicó en apartados anteriores, en la paginación simple cada proceso dispone de su propia TP y, cuando carga todas sus páginas en la memoria principal, se crea y carga en la memoria principal una tabla de páginas. Cada entrada de la TP contiene el número de marco de la correspondiente página en la memoria principal. Si se considera un esquema de memoria virtual 43
PFC: Análisis TLB – Mónica Larruy Carrete basado en paginación se necesita también la TP. Donde se asociará una única TP para con cada proceso. Figura 16: Formato dirección virtual en memoria virtual basada en paginación Figura 17: Entrada de la TP en memoria virtual basada en paginación Debido a que sólo algunas de las páginas de un proceso pueden estar en memoria principal, se necesita un bit de presencia (P) en cada entrada de la tabla para indicar si la página correspondiente está presente o no en la memoria principal. Si el bit indica que la página está en memoria, la entrada incluye también el número de marco para dicha página. Otro bit de control necesario es el de modificación (M), para indicar si el contenido de la página correspondiente se ha alterado desde que la página se cargó en la memoria principal. También pueden estar presentes otros bits de control, como podrían ser la protección o la compartición. Traducción de direcciones Las transferencias desde la memoria secundaria hacia la principal se realizan normalmente bajo demanda (paginación por demanda). Cuando un proceso necesita acceder a una página que no está en memoria principal (a lo que se denomina fallo de página), el SO se encarga de transferirla desde la memoria secundaria. Si al intentar traer la página desde memoria secundaria se detecta que no hay espacio en la memoria principal (no hay marcos libres), será necesario expulsar una página de la memoria principal y transferirla a la secundaria. Por tanto, las transferencias desde la memoria principal hacia la secundaria se realizan normalmente por expulsión. El mecanismo básico de lectura de una palabra de la memoria supone la traducción por medio de la tabla de páginas de una dirección virtual o lógica, formada por un número de página y un desplazamiento, a una dirección física que está formada por un número de marco y un desplazamiento. Debido a que la tabla de páginas es de longitud variable, en función del tamaño del proceso, no es posible suponer que quepa en los registros. En su lugar, debe estar en la memoria principal para poder ser accesible. 44
PFC: Análisis TLB – Mónica Larruy Carrete Figura 18: Traducción de direcciones mediante paginación en memoria virtual Cuando se ejecute un proceso, la dirección de comienzo de la tabla de páginas para este proceso se mantendrá en un registro. El número de página de la dirección virtual se usará como índice en esta tabla para buscar el número de marco correspondiente. Éste se combina con la parte de desplazamiento de la dirección virtual para generar la dirección real. Para construir un esquema de memoria virtual sobre un procesador que ofrezca paginación, se utiliza el bit de la entrada de la tabla de páginas que indica si la página es válida. Estarán marcadas como inválidas todas las entradas correspondientes a las páginas que no están residentes en memoria principal en ese instante. Para estas páginas, en vez de guardarse la dirección del marco, se almacenará la dirección del bloque del dispositivo que contiene la página. Cuando se produzca un acceso a una de estas páginas, se producirá una excepción (fallo de página) que activará al SO que será el encargado de traerla desde la memoria secundaria. Cabe destacar que al utilizar el bit de validez para marcar la ausencia de una página y para indicar que una página es inválida (una página que corresponde con un hueco en el mapa), es necesario que SO almacene información asociada a la página para distinguir entre esos dos casos. Por último, hay que comentar que algunos sistemas de memoria virtual usan la técnica de la prepaginación. En un fallo de página no sólo se traen la página en cuestión, sino también las páginas adyacentes, ya que es posible que el proceso las necesite en un corto plazo de tiempo. La efectividad de esta técnica dependerá de la existencia de acierto en esta predicción. 45
PFC: Análisis TLB – Mónica Larruy Carrete Tratamiento del fallo de página La paginación por demanda presenta excepciones de fallo de página que advierten al SO que debe traer una página de memoria secundaria a primaria ya que un proceso la requiere. A continuación, se especifican los pasos típicos en el tratamiento de un fallo de página: 1º) La MMU produce una excepción y deja en un registro especial la dirección que causó el fallo. 2º) Se activa el SO que comprueba si se trata de una dirección correspondiente a una página inválida o a una página ausente de memoria. Si la página es inválida, se aborta el proceso o se le manda una señal. En caso contrario, se realizan los pasos que se describen a continuación. 3º) Se consulta la tabla de marcos para buscar uno libre. 4º) Si no hay un marco libre, se aplica el algoritmo de reemplazo para seleccionar una página para expulsar. El marco seleccionado se desconectará de la página a la que esté asociado poniendo como inválida la entrada correspondiente. Si la página está modificada, previamente hay que escribir su contenido a la memoria secundaria. 5º) Una vez que se obtiene el marco libre, se inicia la lectura de la nueva página sobre el marco y, al terminar la operación, se rellena la entrada correspondiente a la página para que esté marcada como válida y apunte al marco utilizado. Tal como se puede observar, en el peor de los casos, un fallo de página puede causar dos operaciones de entrada/salida al disco. Políticas de administración de la memoria virtual En un sistema de memoria virtual basado en paginación hay básicamente dos políticas que definen el funcionamiento del sistema de memoria: ‐ Política de reemplazo. Determina qué página debe ser desplazada de la memoria principal para dejar sitio a la página entrante. ‐ Política de asignación de espacio a los procesos. Decide cómo se reparte la memoria física entre los procesos existentes en un determinado instante. 46
PFC: Análisis TLB – Mónica Larruy Carrete 3.4.6.3.
Segmentación En la segmentación simple, se mencionó que cada proceso posee su propia tabla de segmentos (TS) y que, cuando todos los segmentos están en la MP, la TS del proceso se crea y se carga en la memoria. Cada entrada de la TS posee la dirección de comienzo del segmento correspondiente de la MP, así como su longitud. Esta misma estructura; una TS, se necesitará en memoria virtual basada en segmentación. Aquí, se asociará, de nuevo, una TS a cada proceso. Figura 19: Formato dirección virtual en memoria virtual basada en segmentación Figura 20: Entrada de la TS en memoria virtual basada en segmentación Al igual que ocurre con la memoria virtual basada en paginación, sólo algunos de los segmentos de un proceso estarán en la MP, debido a ello se necesita un bit en cada entrada de la TS para indicar si el segmento se encuentra en la MP. Si el bit indica que el segmento está en la memoria, la entrada incluirá también la dirección de inicio y la longitud del segmento. También se necesitará el bit de modificación, para indicar si el contenido del segmento ha sido modificado desde que se cargó en la MP. Otros bits necesarios son los de protección y los de compartición. Traducción de direcciones Para leer una palabra de la memoria habrá que traducir una dirección lógica o virtual (número_segmento:desplazamiento) a una dirección física mediante la TS. Figura 21: Traducción de direcciones mediante segmentación en memoria virtual 47
PFC: Análisis TLB – Mónica Larruy Carrete Al ejecutarse un proceso, la dirección de inicio de la TS de dicho proceso se guardará en un registro. El número de segmento de la dirección virtual se usa como índice de la tabla para buscar la dirección de la MP correspondiente al comienzo del segmento. Ésta se añade a la parte de desplazamiento de la dirección virtual para generar la dirección real. 3.4.6.4.
Características de la paginación y la segmentación Los procesos se ejecutan sólo en MP, también conocida como memoria real. Aunque el usuario percibe una memoria mucho mayor (situada en el disco), la cual se denomina memoria virtual. Esta última memoria permite multiprogramación efectiva y releva al usuario de las altas restricciones de la MP. La tabla 4 resume las características de la paginación y segmentación, con y sin memoria virtual. Paginación simple La MP (Memoria Principal) está divida en trozos pequeños de tamaño fijos llamados marcos. El compilador o el sistema de gestión de memoria dividen los programas en páginas. Memoria virtual paginada Segmentación simple Memoria virtual segmentada La MP está divida en trozos La MP no está dividida. pequeños de tamaño fijos llamados marcos. La MP no está dividida. El compilador o el sistema de gestión de memoria dividen los programas en páginas. El programador indica al compilador los segmentos del programa (es decir, el programador toma la decisión). Fragmentación interna en Fragmentación interna en No existe fragmentación los marcos. los marcos. interna. El programador indica al compilador los segmentos del programa (es decir, el programador toma la decisión). No existe fragmentación interna. No existe fragmentación externa. El SO (Sistema Operativo) debe tener una TP (Tabla de Páginas) para cada proceso, indicando en qué marco está cada página. Fragmentación externa. Fragmentación externa. El SO debe tener una TS (tabla de segmentos) para cada proceso, indicando la dirección de carga y la longitud de cada segmento. El SO debe mantener una lista de huecos libres en la MP. El procesador usa el nº de segmento y el desplazamiento para calcular las direcciones absolutas. Todos los segmentos de un proceso tienen que estar en la MP para que el proceso se ejecute, a El SO debe tener una TS para cada proceso, indicando la dirección de carga y la longitud de cada segmento. No existe fragmentación externa. El SO debe tener una TP para cada proceso, indicando en qué marco está cada página. El SO debe mantener una El SO debe mantener una lista de marcos libres. lista de marcos libres. El procesador usa el nº de página y el desplazamiento para calcular las direcciones absolutas. El procesador usa el nº de página y el desplazamiento para calcular las direcciones absolutas. Todas las páginas de un proceso tienen que estar en la MP para que el proceso se ejecute, a No todas las páginas de un proceso tienen que estar en marcos de la MP para que el proceso se ejecute. El SO debe mantener una lista de huecos libres en la MP. El procesador usa el nº de segmento y el desplazamiento para calcular las direcciones absolutas. No todos los segmentos de un proceso tienen que estar en marcos de la MP para que el proceso se 48
PFC: Análisis TLB – Mónica Larruy Carrete menos que superposición. se use Las páginas se pueden leer menos que cuando se necesiten. superposición. La carga de una página en la MP puede requerir descargar otra en el disco. se use ejecute. Los segmentos se pueden leer cuando se necesiten. La carga de un segmento en la MP puede exigir descargar uno o más segmentos en el disco. Tabla 4: Características de la paginación y la segmentación 3.4.6.5.
Paginación y segmentación combinadas Tanto la paginación como la segmentación tienen sus ventajas. La paginación elimina la fragmentación externa y de este modo, aprovecha la memoria principal de forma eficiente. Además, puesto que los fragmentos que se cargan y descargan de la memoria principal son de tamaño fijo e iguales, es posible construir algoritmos se gestión de memoria sofisticados que aprovechen mejor el comportamiento de los programas. La segmentación tiene las ventajas antes citadas, incluida la capacitación de gestionar estructuras de datos que puedan crecer, la modularidad y el soporte de la compartición y la protección. Para combinar las ventajas de ambas, algunos sistemas están equipados con hardware del procesador y software del SO. En un sistema con paginación y segmentación combinadas, el espacio de direcciones de un usuario se divide en varios segmentos según el criterio del programador. Cada segmento se vuelve a dividir en varias páginas de tamaño fijo, que tienen la misma longitud que un marco de memoria principal. Si el segmento tiene menor longitud que la página, el segmento ocupará sólo una página. Desde el punto de vista del programador, una dirección lógica todavía está formada por un número de segmento y un desplazamiento en el segmento. Desde el punto de vista de sistema, el desplazamiento del segmento se ve como un número de página dentro del segmento y un desplazamiento dentro de la página. Figura 22: Traducción de direcciones en un sistema con paginación y segmentación en memoria virtual 49
PFC: Análisis TLB – Mónica Larruy Carrete La entrada de la tabla de segmentos posee la longitud del segmento. Los bits de presencia y modificación no son necesarios, ya que se gestionan en la página. Pueden usarse otros bits de control para compartición y protección. La entrada de la tabla de páginas es, la misma que se usa en un sistema de paginación pura. Cada número de página se convierte en el número de marco correspondiente si la página está presente en la memoria. El bit de modificación indica si se necesita escribir la página en el disco cuando se asigna el marco a otra página. Ventajas Posee todas las ventajas de la paginación y la segmentación: ‐
Debido a que los espacios de memorias son segmentados, se garantiza la facilidad de implantar la compartición y enlace. ‐
Como los espacios de memoria son paginados, se simplifican las estrategias de almacenamiento. ‐
Se elimina el problema de la fragmentación externa y la necesidad de compactación. Inconvenientes ‐ Las tres componentes de la dirección y el proceso de formación de direcciones hace que se incremente el coste de su implantación. El coste es mayor que en el caso de de segmentación pura o paginación pura. ‐ Se hace necesario mantener un número mayor de tablas en memoria, lo que implica un mayor coste de almacenamiento. Sigue existiendo el problema de fragmentación interna de todas (o casi todas) las páginas finales de cada uno de los segmentos. Bajo paginación pura se desperdicia solo la última página asignada, mientras que bajo segmentación y paginación combinadas, el desperdicio puede ocurrir en todos los segmentos asignados. 50
PFC: Análisis TLB – Mónica Larruy Carrete 3.4.7. Técnicas de gestión de memoria Una de las técnicas más simples para la gestión de la memoria es la partición, la cual se ha ido usando con diferentes variantes en algunos sistemas ahora obsoletos. Por su parte, la paginación simple y la segmentación simple, no se usan en solitario. Actualmente, la gestión de memoria requiere memoria virtual. Ésta se basa en paginación o segmentación. Técnica ESQUEMAS DE ASIGNACIÓN CONTIGUA Partición estática Partición dinámica ESQUEMAS DE ASIGNACIÓN NO CONTIGUA Paginación simple Segmentación simple ESQUEMAS CON MEMORIA VIRTUAL Memoria paginada Descripción Ventajas Desventajas La memoria principal (MP) se divide en un conjunto de particiones estáticas durante la generación del sistema. Un proceso se puede cargar en una partición de menor o igual tamaño. Las particiones se crean dinámicamente, de forma que cada proceso se carga en una partición de su mismo tamaño. Sencilla de implementar, Uso ineficiente de la poca sobrecarga del SO. memoria por culpa de la fragmentación interna (el número de procesos activos es fijo) No hay fragmentación interna, uso más eficiente de la memoria principal. La MP se divide en un conjunto de marcos de igual tamaño. Cada proceso se divide en páginas de igual tamaño que los marcos. Un proceso se carga situando todas sus páginas en marcos libres que no tienen porque ser contiguos. Cada proceso se divide en segmentos. Un proceso se carga situando todos sus segmentos en particiones dinámicas pero no necesariamente continuas. No tiene fragmentación Hay una pequeña cantidad externa. de fragmentación interna. Uso ineficiente del procesador, ya que se usa la compactación para contrarrestar la fragmentación externa. No tiene fragmentación Mejora la utilización de la interna. memoria y reduce la sobrecarga comparada con la partición dinámica virtual Igual que la paginación simple, No hay fragmentación Sobrecarga por gestión excepto que no hace falta cargar todas las páginas de un proceso. Las páginas no residentes que se necesiten se traerán más tarde, automáticamente. Memoria virtual Igual que la segmentación simple, excepto que no es necesario cargar segmentada todos los segmentos de un proceso. Los segmentos no residentes que sean necesarios se traerán más tarde, automáticamente. externa. compleja de memoria. Alto grado de multiprogramación. Gran espacio virtual para el proceso. No hay fragmentación Sobrecarga por gestión interna. compleja de memoria. Alto grado de multiprogramación. Gran espacio virtual para el proceso. Soporte de protección y compartición. Tabla 5: Resumen de las técnicas de gestión de memoria 51
PFC: Análisis TLB – Mónica Larruy Carrete 4. TLB (Translation Lookaside Buffer) 4.1. Introducción En casi todos los esquemas de paginación, las tablas de páginas se mantienen en la memoria, debido a su gran tamaño. Este diseño podría tener un impacto enorme en el desempeño. Por ejemplo, consideremos una instrucción que copia un registro en otro. Si no hay paginación, la instrucción sólo efectúa una referencia a la memoria, para traer la instrucción. Si hay paginación, se requerirán referencias adicionales a la memoria para tener acceso a la tabla de páginas. Puesto que la velocidad de ejecución por lo general está limitada por la velocidad con que la CPU puede sacar instrucciones y datos de la memoria, tener que hacer dos referencias a la tabla de páginas por cada referencia a la memoria reduce el desempeño en 2/3. En tales condiciones, nadie usaría paginación. Los diseñadores de computadores han sido conscientes de este problema desde hace años, y han ideado una solución basada en la observación de que los programas tienden a hacer un gran número de referencias a un número pequeño de páginas, y no al revés. Por lo tanto, sólo una fracción pequeña de las entradas de la tabla de páginas se lee mucho; el resto casi no se usa. La solución que se encontró consiste en equipar a los computadores con un pequeño dispositivo de hardware que traduce direcciones virtuales a físicas, sin pasar por la tabla de páginas. Este dispositivo, se trata de una caché de acceso rápido denominada TLB (Translation Looakside Buffer). 4.1.1. Soporte hardware a las tablas de páginas (TP) 4.1.1.1.
Registros dedicados Como la TP de cada proceso puede llegar a ser demasiado grande, se buscan mecanismos que permitan acelerar el tiempo de búsqueda en esa información. La solución más simple es la utilización de un conjunto de registros dedicados (no usar tabla de paginación de cada proceso). El CPU dispatcher será el encargado de cargar y actualizar la información de estos registros con cada contexto. El uso de registros para la TP es únicamente satisfactorio si la tabla es razonablemente pequeña. 52
PFC: Análisis TLB – Mónica Larruy Carrete 4.1.1.2.
Registros asociativos (TLB) Si bien el esquema de memoria virtual basado en paginación, expuesto anteriormente, funciona correctamente, presenta serios problemas a la hora de implementarlo directamente. Estos problemas surgen debido a la necesidad de mantener las TP en memoria principal. Esto conlleva problemas de eficiencia y de consumo de espacio. Por lo que se refiere a los problemas de eficiencia, dado que para acceder a la posición de memoria solicitada, la MMU debe consultar la entrada correspondiente de la TP, se producirán dos accesos a memoria por cada acceso real solicitado por el programa. Esta sobrecarga es intolerable, ya que reduciría a la mitad el rendimiento del sistema. Para solventar este problema, la MMU incluye internamente una especie de caché de traducciones llamada TLB (Translation Lookaside Buffer), cuyo modo de operación se mostrará en el siguiente apartado. 4.2. Funcionamiento Cada referencia a la memoria virtual genera normalmente dos accesos a la memoria: 1) Para obtener la dirección física. 2) Para acceder a los datos. Ante ello, la memoria virtual podría causar el efecto de doblar el tiempo de acceso a la memoria. Para solucionarlo, generalmente se usa una caché especial para las entradas de la tabla de páginas, conocida como buffer de traducción adelantada (TLB). Su funcionamiento es similar a una caché. Ésta guarda las entradas de la tabla de páginas a las que se haya hecho referencia recientemente. Un TLB es una caché que almacena sólo las correspondencias de tablas de páginas. Por tanto, cada etiqueta de las entradas del TLB posee una parte del número de página virtual, y un número de página físico: D ire c c ió n v irtu a l
F la g s
(D irty , P ro te c c ió n , U s o )
D ire c c ió n fís ic a
Figura 23: Formato de la etiqueta de la entrada del TLB 53
PFC: Análisis TLB – Mónica Larruy Carrete 4.3. Diseño Para hacer que un sistema de paginación sea aplicable en la práctica es necesario que la mayoría de los accesos a memoria no impliquen una consulta a la tabla de páginas, sino que únicamente requieran el acceso a la posición solicitada. De esta forma, el rendimiento será similar al de un sistema sin paginación. Como se comentó previamente, esto se logra mediante el uso del TLB. Se trata de una pequeña memoria asociativa interna a la MMU que mantiene información sobre las últimas páginas accedidas. Cada entrada en el TLB es similar a la de la tabla de páginas (número de marco, protección, bit de referencia, etc.), pero incluye también el número de la página para permitir realizar una búsqueda asociativa. Existen dos alternativas en el diseño de un TLB dependiendo de si se almacenan identificadores de proceso o no. ‐
TLB sin identificadores de proceso. La MMU accede al TLB sólo con el número de página. Por tanto, cada vez que hay un cambio de proceso el SO debe invalidar el TLB ya que cada proceso tiene su propio mapa. ‐
TLB con identificadores de proceso. La MMU accede al TLB con el número de página y un identificador de proceso. En cada entrada del TLB, por tanto, se almacena también este identificador. La MMU obtiene el identificador de un registro del procesador. El SO debe encargarse de asignarle un identificador a cada proceso y de rellenar este registro en cada cambio de proceso. De esta forma, no es necesario que el sistema operativo invalide el TLB en cada cambio de proceso, pudiendo existir en el TLB entradas correspondientes a varios procesos. Tradicionalmente, el TLB ha sido gestionado directamente por la MMU sin intervención del SO. La MMU consulta el TLB y, si se produce un fallo debido a que la traducción de esa página no está presente, la propia MMU se encarga de buscar la traducción en la tabla de páginas e insertarla en el TLB. De hecho, el TLB es casi transparente al SO, que sólo debe encargarse en cada cambio de proceso de solicitar a la MMU su volcado y, en caso de que no use identificadores de proceso, su invalidación. Cabe destacar que es necesario realizar un volcado del TLB a la tabla de páginas, ya que la información de los bits de página accedida o modificada se actualiza directamente en el TLB, pero no en la tabla de páginas. Algunos procesadores (como, por ejemplo, MIPS o Alpha) tienen un diseño alternativo en el que se traspasa parte de la gestión del TLB al SO. A este esquema se le denomina TLB gestionado por software (ver apartado 7.6). La MMU se encarga de buscar la traducción en el TLB, pero si no la 54
PFC: Análisis TLB – Mónica Larruy Carrete encuentra produce una excepción que activa al SO. Éste se debe encargar de buscar “a mano” en la tabla de páginas e insertar en el TLB la traducción. Cabe destacar que, con este esquema, la MMU se simplifica considerablemente, ya que no tiene que saber nada de las tablas de páginas. Además, proporciona más flexibilidad, ya que el SO puede definir las tablas de página a su conveniencia, sin ninguna restricción impuesta por el hardware. Como contrapartida, el sistema será menos eficiente, ya que parte del proceso de traducción se realiza por software. 4.4. Acceso Figura 24: Uso del TLB En cada referencia se busca el número de página virtual en el TLB. Si se acierta, el número de página física se usa para formar la dirección y el correspondiente bit se activa. Si por el contrario no se encuentra, habrá que determinar si es un fallo en el TLB o bien un fallo de página. Si la página está en memoria, el TLB indica que no contiene la traducción. En estos casos, la CPU gestiona el fallo de TLB cargando la traducción de la tabla de páginas en el TLB y después repite la referencia. Si la página no se encuentra en memoria, el TLB indicará que se trata de un fallo de página. Aquí la CPU invocaría al SO lanzando una excepción. Como el TLB tiene menos entradas que el número de páginas de la memoria principal, los fallos de TLB serán más frecuentes que los fallos de página. 55
PFC: Análisis TLB – Mónica Larruy Carrete 4.5. Reemplazo Después del fallo de TLB, se necesitará seleccionar una entrada del TLB para ser reemplazada. Como la entrada del TLB contiene los bits de referencia y suciedad; se activa cuando se escribe en la página, si el SO escoge una cierta página para ser reemplazada, este bit indicará si se debe guardar la página antes de ser reemplazado su lugar por otra página, se deben copiar en la entrada de la tabla de páginas correspondiente. Estos bits son la única parte de una entrada en el TLB que pueden cambiar. Usando la estrategia de escritura diferida (es decir, copiar las entradas cuando ocurre un fallo en vez de copiarlas siempre que se haga una escritura) es muy eficiente, ya que la tasa de fallos del TLB pasa a ser muy pequeña. Existen sistemas que utilizan otras técnicas para los bits de referencia y suciedad, eliminando la necesidad de escribir en el TLB excepto en el caso de cargar una nueva entrada después de un fallo. Figura 25: Funcionamiento de la paginación con TLB 56
PFC: Análisis TLB – Mónica Larruy Carrete En la figura 25 se muestra un diagrama de flujo representando el uso del TLB, obviando que el SO puede pasar a ejecutar otro proceso mientras se realiza la E/S a disco. Aquí se puede apreciar que si una página no está en memoria principal, una interrupción de fallo de página llamará a la rutina de gestión de fallos de página. Debido al principio de cercanía, la mayoría de las referencias a la memoria virtual se situarán en las páginas usadas recientemente. Por consiguiente, la mayoría de las referencias van a involucrar a las entradas de la tabla de páginas en la caché. 4.6. Gestión de los fallos de página y del TLB La traducción de direcciones virtuales a direcciones físicas usando un TLB es fácil en el caso de acertar en el TLB, gestionar los fallos de éste y los fallos de página es más complejo. Un fallo de TLB, tal como se ha mencionado anteriormente, ocurre cuando ninguna entrada del TLB corresponde a una dirección virtual pedida. Este fallo puede indicar: 1) La página está en memoria y basta con crear la entrada en el TLB. 2) La página no está en memoria y se tiene que transferir el control al SO para gestionar el fallo. Para determinar cuál de los dos casos ha ocurrido, basta con procesar un fallo de TLB y buscar una entrada de la tabla de páginas para poner en el TLB. Si dicha página tiene el bit de validez desactivado, implica que no está en memoria principal, dando lugar a un fallo de página. En cambio si el bit de validez está activado, se puede copiar el número de página física de la entrada de la tabla de páginas y usarlo para crear la entrada en el TLB. Si bien el fallo de TLB se puede solucionar mediante hardware o software, el fallo de página necesita usar excepciones para interrumpir el proceso activo, transferir el control al SO y más tarde reanudar el proceso interrumpido. La excepción del fallo de página se debe activar al final del ciclo en que se da el acceso a memoria, para que en el siguiente ciclo se empiece el procesamiento de la excepción y no la continuación de la ejecución de las instrucciones. Este último tipo de excepciones son extremadamente difíciles de resolver si ocurre por accesos a datos, ya que ocurren en medio de instrucciones, éstas no se pueden completar antes de tratar la excepción y, después de haber tratado la excepción, se debe volver a ejecutar la instrucción como si no hubiese ocurrido nada. 57
PFC: Análisis TLB – Mónica Larruy Carrete Cabe mencionar que debido a que el TLB es un subconjunto de la tabla de páginas accedido en cada ciclo, las violaciones de protección son también excepciones del TLB. Un conjunto de valores en el registro de causa indicarán las violaciones de protección. Como podría ocurrir al intentar escribir estando el bit de escritura desactivado. Para poder avisar del error, el SO puede acceder al TLB o a la entrada de la tabla de páginas de la página virtual correspondiente y determinar así los permisos de acceso. 4.7. TLB gestionado por software Se da por hecho que toda máquina que tiene memoria virtual paginada tiene tablas de páginas que el hardware reconoce, más un TLB. En este diseño, el hardware de la MMU realiza por completo la administración y el manejo de fallos del TLB. Sólo se salta al SO cuando una página no está en la memoria. En el pasado siempre era válida dicha suposición, pero máquinas RISC (SPARC, MIPS, Alpha y HP PA) efectúan prácticamente toda la administración de páginas por software. En dichas máquinas, el SO carga de forma explícita las entradas del TLB. Cuando no se encuentra una página en el TLB, en lugar de que la MMU consulte directamente la TP para hallar y obtener la referencia de página requerida, simplemente genera un fallo de TLB y deja que el SO resuelva el problema. El SO tendrá que encontrar la página, desalojar una entrada del TLB, cargar la nueva y reiniciar la instrucción que causó el fallo. Y, como es obvio, todo ello debe poder hacerse con muy pocas instrucciones, ya que los fallos de TLB, tal como ya se ha indicado, ocurren con más frecuencia que los de página. Si el TLB tiene un tamaño razonable (digamos que unas 64 entradas) se consigue que la tasa de fallos no sea muy alta y, la administración del TLB por software alcanza una eficiencia aceptable. Con ello se consigue simplificar muchísimo la MMU y poder así contar con más espacio en el chip de la CPU para cachés y otros recursos. Se han desarrollado diversas estrategias para mejorar el rendimiento en máquinas que efectúan la administración del TLB por software. Una de ellas busca reducir los fallos del TLB y, al mismo tiempo, disminuir el coste de los que sí ocurran. Para rebajar el número de fallos de TLB, en algunas ocasiones el SO puede utilizar su intuición para determinar qué páginas tienen la probabilidad más alta de utilizarse a continuación y precargar entradas en el TLB para ellas. Por ejemplo, si un proceso cliente envía un mensaje a un proceso servidor que está en la misma máquina, es muy probable que el servidor tenga que ejecutarse pronto. Sabiendo esto, el sistema puede determinar, mientras procesa la instrucción para enviar información, dónde están las 58
PFC: Análisis TLB – Mónica Larruy Carrete páginas de código, datos y pila del servidor, y colocar entradas para ellas en el TLB antes de que puedan causar fallos de TLB. La forma normal de procesar un fallo de TLB, ya sea por hardware o por software, es consultando la tabla de páginas y realizar las operaciones de indexación necesarias para localizar la página a la que se hizo referencia. Lo malo de realizar la búsqueda por software es que las páginas que contienen la tabla de páginas podrían no estar en el TLB, lo cual causaría fallos de TLB adicionales durante el procesamiento. Estos fallos pueden reducirse si se mantiene una caché grande de software (por ejemplo, de 4KB) con entradas de TLB, en un lugar fijo cuya página siempre se conserve en el TLB. Si el SO consulta la caché de software, podrá reducir considerablemente los fallos de TLB. 4.8. Indexación TLB El TLB únicamente contiene algunas de las entradas de la tabla de páginas completa, por lo que no se puede indexar el TLB sólo por el número de página. En su lugar, cada entrada del TLB debe incluir el número de página junto con la entrada completa a la tabla de páginas. Esta técnica se conoce como correspondencia asociativa (cada número de página se puede colocar en cualquier lugar de la caché) y contrasta con la correspondencia directa usada para buscar en la tabla de páginas: Figura 26: Búsqueda directa y asociativa en entradas de la tabla de páginas 59
PFC: Análisis TLB – Mónica Larruy Carrete Por otro lado, la memoria virtual debe interaccionar con la caché de la memoria principal: Figura 27: Traducción con TLB y uso de caché Una dirección virtual suele estar formada por el número de página y el desplazamiento. Primero, el sistema de memoria consulta el TLB para ver si encuentra la entrada de la tabla de páginas. Si es así, la dirección real/física se genera combinando el número de marco y el desplazamiento. Si no, se accede a la entrada de la tabla de páginas. A continuación, se consulta la caché para ver si está el bloque con dicha palabra. Si lo está, es devuelto a la CPU. En caso contrario, se coge la palabra de la memoria principal. 4.9. Tamaño de página El tamaño de página es un elemento que influye en el rendimiento del sistema. Si son muy pequeños se evita la fragmentación, pero las tablas de página aumentarían mucho en tamaño, y aumentaría el número de intercambios entre memoria principal y disco. A medida que crece el tamaño de los procesos en la memoria y decrece su cercanía5, disminuye el porcentaje de acierto en los accesos a la TLB. En esta situación, la TLB puede llegar a generar un cuello de botella del rendimiento. Una forma de aumentar el rendimiento de la TLB es usar mayores TLB y con más entradas. No obstante, el tamaño de la TLB afecta a aspectos tales como la caché de memoria principal y el número de accesos a la memoria por ciclo de instrucción. Una alternativa sería usar tamaños de Principio de cercanías: las referencias a memoria tienden a agruparse. 5
Se realiza el agrupamiento de las lecturas de memoria por medio de la unidad central de procesamiento. Las mismas, ya sean para instrucciones o para leer datos, se mantienen por lo general dentro de grupos de direcciones relativamente cercanas entre sí. 60
PFC: Análisis TLB – Mónica Larruy Carrete página grandes para que cada entrada a la tabla de páginas de la TLB haga referencia a un bloque de memoria mayor. Sin embargo, el uso de tamaño de páginas grandes puede suponer una degradación del rendimiento. Debido a ello, diferentes diseñadores han investigado el uso de diferentes tamaños de páginas en varias arquitecturas, y se ha visto que múltiples tamaños de página proporcionan la suficiente flexibilidad para usar eficazmente un TLB. 4.10. Entrada TLB El TLB suele contener un número pequeño de entradas (casi nunca más de 64). Cada entrada contiene información sobre una página: ‐
Bit de validez ‐
Nº de página ‐
Bit de modificado ‐
Bit de protección ‐
Nº de marco de página Valid
1
1
1
1
1
1
1
Virtual page
140
30
754
98
23
14
854
Modified Protection Page frame
1
RW 65 0
R X 14 0
RW 50 1
RW 12 1
R X 59 1
RW 21 0
R X 43 Tabla 6: Ejemplo de entradas del TLB 4.10.1.
Valores típicos de parámetros para un TLB Tamaño de bloque 4‐32 bytes (una entrada de página)
Tiempo de acierto 1 ciclo de reloj
Penalización de fallos
10‐100 ciclos de reloj
Frecuencia de fallos 0.01%‐2%
Tamaño TLB 32‐8192
Tabla 7: Valores típicos de parámetros para TLB Además de estos parámetros, la correspondencia de traducciones a entradas en el TLB varía considerablemente. Muchos sistemas usan TLB totalmente asociativo (un bloque puede estar en cualquier parte del TLB) porque se tiene una tasa de fallos más baja, y además al ser el TLB pequeño, el coste de una correspondencia asociativa no es muy elevado. Pero se presenta el problema de que los fallos de TLB son más frecuentes que los de página, y se desea tratarlos de 61
PFC: Análisis TLB – Mónica Larruy Carrete forma “barata”. Por ello, muchos sistemas ofrecen soporte para escoger aleatoriamente la entrada a reemplazar. Si bien, a menudo el TLB se presta a ser totalmente asociativo, se suele implantar con frecuencia la ubicación asociativa por conjuntos (el bloque puede encontrarse en un conjunto restringido de posiciones) para las cachés y el TLB, donde el acceso combina indexación y la búsqueda de un pequeño conjunto. En la mayoría de las máquinas medianas se emplea asociatividad por conjuntos. 4.11. Integración de la memoria virtual, los TLBs y las cachés A continuación, se exponen las posibles combinaciones de sucesos en memoria virtual, caché y TLB, presuponiendo que todas las direcciones de memoria se traducen a direcciones físicas antes de acceder a caché (Ejemplo de esta organización de memoria en la figura 29: MIPS R2000). Caché TLB Memoria virtual ¿Posible? Si es así, ¿en qué circunstancias? Fallo Acierto Acierto Posible, pero no se comprueba la tabla de páginas si acierta en el TLB Acierto Fallo Acierto Fallo de TLB, aunque la entrada está en la tabla de páginas; después de reintentar se acierta en la caché Fallo Fallo Acierto Fallo de TLB, aunque la entrada está en la tabla de páginas; después de volver a probar se acierta en la caché Fallo Fallo Fallo Fallo de TLB y de página; después de reintentar se tiene que fallar en la caché Fallo Acierto Fallo Imposible: no se puede tener una traducción en el TLB de una página que no está en memoria Acierto Acierto Fallo
Imposible: no se puede tener una traducción en el TLB de una página que no está en memoria Acierto Fallo Imposible: no se pueden tener una datos en la caché que no se encuentren en la memoria Fallo
Tabla 8: Posibles sucesos entre memoria virtual, caché y TLB También es posible que la CPU indexe a la caché con una dirección virtual. Es lo que se conoce como caché direccionable virtualmente. En este tipo de cachés, el acceso a la caché y al TLB 62
PFC: Análisis TLB – Mónica Larruy Carrete ocurre en paralelo. Pero en caso de fallo de caché, el procesador debe traducir la dirección a una dirección física para poder ir a buscar el bloque de caché a la memoria principal. Al acceder a caché con una dirección virtual y existiendo compartición de páginas entre programas, se puede producir aliasing (efecto alias). Ello ocurre cuando se tienen dos direcciones virtuales para la misma página. Llegando a provocar que una palabra de una página esté en la caché en dos posiciones diferentes, cada una asociada a una dirección virtual diferente. Para reducir el efecto, se introducen limitaciones en el diseño de la caché y del TLB, o bien el propio SO se encarga de evitar que ocurra. Otra opción serían las cachés indexadas con direcciones virtuales que usan etiquetas de direcciones físicas. De esta manera, se consiguen fusionar las ventajas de ambas alternativas. Aquí la caché y el TLB se acceden en paralelo, y las etiquetas de las direcciones físicas de la caché son comparadas con la dirección física del TLB. 63
PFC: Análisis TLB – Mónica Larruy Carrete 4.12. IMPLEMENTACIONES 4.12.1.
Introducción El primer ordenador que dispuso de memoria virtual era el Atlas, propuesto por Kilburn. Ello ocurrió en 1963, el año anterior de que fuese anunciado el IBM 360. IBM pensaba incluir memoria virtual en la siguiente generación (Sistema/370), pero el SO no estaba preparado en 1970. Debido a ello, la memoria virtual se anunció para la familia 370 en 1972, y fue en esta máquina donde se acuñó el término de buffer de traducciones anticipadas (TLB). 4.12.2.
VAX­11/780 Máquina CISC sucesora de la PDP‐11, producida por Digital Equipment Corporation. Su nombre original era VAX‐11 (Virtual Address Extended PDP‐11). Lanzada el 25 de octubre de 1977, fue la primera máquina comercial de arquitectura de 32 bits, lo que la convierte en un hito destacable en la historia de la computación. La primera VAX‐11/780 fue instalada en Carnegie Mellon University. Tamaño de página de 512 bytes
Entrada Tabla de páginas de 4 bytes TLB de 512 bytes asociativa por conjuntos de 2 vías Pasos: 1) Envío del índice de la dirección virtual 2) Comprobación de válido y tipo de acceso a memoria 3) Comprobación de etiquetas 4) Envío de la dirección física a través del multiplexor 5) Combinación del número y desplazamiento de página Figura 28: TLB del VAX‐11/780 64
PFC: Análisis TLB – Mónica Larruy Carrete 4.12.3.
MIPS R2000 MIPS (Microprocessor without Interlocked Pipeline Stages), es una arquitectura de procesadores tipo RISC desarrollada por MIPS Computer Systems Inc. Los diseños de MIPS se usan en las estaciones de trabajo de SGI6, y tienen mucha implantación en sistemas empotrados, dispositivos que soportan Windows CE, y en los routers de Cisco. La consola Nintendo 64, la Sony PlayStation, la Sony PlayStation 2, y la consola portátil Sony PSP usan procesadores MIPS. A finales de los 90, se estimó que uno de cada tres chips tipo RISC que salieron al mercado estaban basados en MIPS. El primer diseño de MIPS Computer Systems Inc se lanzó en 1985 y es conocido como R2000, se pasó a mejorar el diseño con el R3000 en 1988. El TLB del MIPS R2000 que se usó para la DECStation 3100 es muy sencillo, pero posee la mayoría de las características de los actuales TLBs. El sistema de memoria usa páginas de 4KB y un espacio de direcciones de 32 bits, por lo que el número de página virtual es de 20 bits. La dirección física es del mismo tamaño que la dirección virtual. El TLB contiene 64 entradas, es totalmente asociativo y es compartido entre referencias a instrucciones y a datos. Cada entrada consta de 64 bits y dispone de 20 bits de etiqueta (que son el número de página de virtual de dicha entrada en el TLB), el número de página física (20 bits), un bit de validación, y otros bits de contabilidad Figura 29: TLB del MIPS R2000 6
Silicon Graphics, Inc., también conocida como SGI, o históricamente citada como Sistemas Computacionales Silicon Graphics (SGCS), comenzó como fabricante de terminales gráficas en 1982. La industria de las estaciones de trabajo es el negocio principal de SGI a través de su historia. 65
PFC: Análisis TLB – Mónica Larruy Carrete La figura 29 muestra la organización del TLB y una de las cachés del DECStation 3100. El diagrama adjunto en la figura 30 muestra la gestión de las lecturas. Si bien la caché es de correspondencia directa, el TLB es totalmente asociativo. Esto implica que cada etiqueta del TLB se compare con el índice, ya que la entrada a buscar puede estar en cualquier entrada del TLB. Si el bit de validez correspondiente a la entrada está activo, el acceso al TLB es un acierto, y el número de página junto con el desplazamiento forman el índice que se usará para acceder a la caché. Figura 30: Uso TLB en la DECStation 3100 Anteriormente se muestra el proceso de las lecturas con escritura a través en el TLB y la caché de la DECStation 3100. Si se genera un acierto, se podrá acceder a la caché con la dirección física. Si la operación es una escritura, se sobrescribe la entrada de la caché y los datos se envían al buffer de escrituras. Para una lectura, la caché genera un acierto o fallo y suministra los datos o bien causa un bloqueo. Cabe destacar que un acierto en el TLB y en la caché son sucesos diferentes. A su vez, un acierto en la caché sólo ocurrirá cuando haya un acierto en el TLB, lo que equivale a decir que los datos están en la memoria. 66
PFC: Análisis TLB – Mónica Larruy Carrete 4.12.3.1. Gestión de los fallos En el MIPS R2000, tanto el fallo de TLB como el de página tienen la misma señal en el TLB. Para poder distinguir entre ambos casos, el registro de causa contiene dos valores diferentes. Un valor indica que no hay ninguna entrada en el TLB, mientras que el otro determina que la entrada en el TLB existe pero que la página no se encuentra en memoria. Ante el hecho de que la excepción producida porque la entrada no está en el TLB es más frecuente, el SO actualiza el TLB sin examinar la entrada y ejecuta de nuevo la instrucción después de esta excepción. Si se produce un fallo de página ocurre otra excepción. Este método consigue que el fallo del TLB sea más rápido, pero penalizando el posible fallo de página. 4.12.4.
Intel 4.12.4.1. Intel I960 El primer procesador superescalar, el i960, fue diseñado por Intel en 1989, y podía ejecutar dos instrucciones por ciclo de reloj. Ya en 1995, lo normal era encontrar diseños de cuatro instrucciones por ciclo, y aunque aparecieron algunos como el Power PC capaces de ejecutar hasta seis, entre la complejidad y el choque frontal que supone con la forma en que están escrito los programas, el mercado volvió sobre sus pasos y se encuentra instalado en factores de superescalaridad de entre tres y cuatro. 4.12.4.2. Familia Pentium Esquema En la familia Intel 386/486/Pentium, las páginas son de 4 KB y el espacio de direcciones virtuales es de 4 GB. Una tabla de páginas está restringida a 1024 filas, pero un proceso puede tener hasta 1024 tablas distintas. Cada tabla de páginas sirve para traducir las direcciones de un bloque contiguo de 4 MB de memoria en el espacio de direcciones virtuales. El directorio y las tablas de páginas se almacenan en memoria real en una Intel 386. Con ello, se reduce el tiempo para realizar un cambio de contexto, pero se multiplica por 3 el costo del acceso a la memoria virtual. En efecto cada acceso a la memoria virtual requiere un acceso real en el directorio para determinar la tabla de páginas, otro acceso real en la tabla de páginas y 67
PFC: Análisis TLB – Mónica Larruy Carrete finalmente el acceso real de la palabra solicitada por el proceso. Este nuevo sobrecosto es escandalosamente inaceptable. Para acelerar los accesos a la memoria, el hardware del computador posee un TLB. Sin él, se producirían accesos a dos tablas en la memoria principal (directorio y tabla de páginas), lo que supondría un alto grado de lentitud. Así pues, Intel introdujo dentro del microprocesador una pequeña memoria caché asociativa ultrarrápida denominada TLB. Éste tendrá la traducción de las direcciones lineales a físicas de las últimas páginas (de 32 a 128. Por ejemplo, en el 386 son 32) manejadas. El TLB es una caché asociativa de cuatro vías. Como cada página tiene una longitud de 4KB, esto alcanza a 128KB. Para muchos sistemas multitarea, el TLB tendrá un porcentaje de éxito (hit) del 98%. Esto significa que el procesador deberá acceder a las dos tablas el 2% del tiempo. El TLB es una caché de acceso por contenido: ‐
Etiquetas: dirección lineal. ‐
Datos asociados: dirección física. Cada vez que haya que realizar una traducción se consulta el TLB, y si está guardada, se obtiene en muy poco tiempo. El Pentium contiene dos TLBs independientes de 32 entradas, uno para la caché y otro para la de datos. Maneja 64 páginas y 256 KBytes de memoria. Estos TLBs sólo son visibles para los programas del SO con nivel de prioridad 0. Por su parte, tal como se mostrará posteriormente, los registros TR6 y TR7 permiten leer y escribir en el TLB. Si se desea, se puede llegar a invalidar una entrada concreta del TLB, para ello hay que hacer uso de la instrucción INVLPG. Por su parte, los procesadores Pentium con tecnología MMX7 contienen 64 entradas en el TLB de datos totalmente asociativas, mientras que en el TLB de instrucciones posee 32 entradas, también, completamente asociativas. Ambos TLBs pueden soportar tanto páginas de 4KBytes como de 4MBytes. 7
La tecnología MMX (MultiMedia eXtensions) fue introducida en 1997 por Intel en sus procesadores Pentium para mejorar la manipulación de imágenes y tratamiento de codecs de audio/video, mediante un conjunto de 57 nuevas instrucciones, así como una nueva capacidad denominada SIMD (Single Instrucction Multiple Data). 68
PFC: Análisis TLB – Mónica Larruy Carrete Figura 31: Diagrama de bloques del procesador Pentium Paginación­Segmentación La unidad de manejo de memoria (MMU) consiste en una unidad de segmentación y una unidad de paginado (nuevo en este microprocesador). La segmentación permite el manejo del espacio de direcciones lógicas agregando un componente de direccionamiento extra, que permite que el código y los datos se puedan reubicar fácilmente. El mecanismo de paginado opera por debajo y es transparente al proceso de segmentación, para permitir el manejo del espacio de direcciones físicas. Cada segmento se divide en uno o más páginas de 4 KB. Para implementar un sistema de memoria virtual (aquél donde el programa tiene un tamaño mayor que la memoria física y debe cargarse por partes (páginas) desde el disco rígido), el 80386 permite seguir ejecutando los programas después de haberse detectado fallos de segmentos o de páginas. Si una página determinada no se encuentra en memoria, el 80386 se lo indica al SO mediante la excepción 14, luego éste carga dicha página desde el disco y finalmente puede seguir ejecutando el programa, como si hubiera estado dicha página todo el tiempo. Como se puede observar, este proceso es transparente para la aplicación, por lo que el programador no debe preocuparse por cargar partes del código desde el disco ya que se encarga el SO con la ayuda del microprocesador de realizarlo. 69
PFC: Análisis TLB – Mónica Larruy Carrete Funcionamiento del hardware de paginación. El hardware de paginación opera de la siguiente manera. La unidad de paginación recibe una dirección lineal de 32 bits procedente de la unidad de segmentación. Los 20 bits más significativos son comparados con las 32 entradas del TLB para determinar si la entrada de la tabla de páginas está en el caché. Si está (caché hit), entonces se calcula la dirección física de 32 bits y se la coloca en el bus de direcciones. Si la entrada de la tabla de páginas no se encuentra en el TLB (caché miss), el 80386 leerá la entrada del directorio de páginas que corresponda. Si P=1 (la tabla de páginas está en memoria), entonces el 80386 leerá la correspondiente entrada de la tabla de páginas y pondrá a uno el bit accedido de la entrada del directorio de páginas. Si P=1 en la entrada de la tabla de páginas, indicando que la página se encuentra en memoria, el 80386 actualizará los bits Accedido y Dirty según corresponda y luego accederá a la memoria. Los 20 bits más significativos de la dirección lineal se almacenarán en el TLB para futuras referencias. Si P=0 para cualquiera de las dos tablas, entonces el procesador generará una excepción 14 (Fallo de Página). El procesador también generará una excepción 14, si la referencia a memoria viola los atributos de protección de página (bits U/S y R/W) (por ejemplo, si el programa trata de escribir a una página que es de sólo lectura). En el registro CR2 se almacenará la dirección lineal que causó el fallo de página. En la pila se pondrá un valor de 16 bits que sirve para que el SO sepa por qué ocurrió la excepción. El formato de esta palabra es: ‐
Bits 15‐3: indefinido. ‐
Bit 2: vale 1 si el procesador estaba ejecutando en modo usuario. Vale 0 si el procesador estaba ejecutando en modo superusuario. Nótese que un acceso a una tabla de descriptores siempre se considera modo superusuario, por más que el programa se esté ejecutando en el nivel 3. ‐
Bit 1: vale 1 si el procesador estaba por realizar una escritura. Vale 0 si tenía que realizar una lectura. ‐
Bit 0: vale 1 si hubo una violación de protección en la página. Vale 0 si la página no estaba presente. 70
PFC: Análisis TLB – Mónica Larruy Carrete Registros de control usados para la paginación Figura 32: Registros de control para la paginación en el procesador Pentium El registro CR2 es el que mantiene la dirección lineal de 32 bits que causó el último fallo de página detectado por el microprocesador. El registro CR3 contiene la dirección física inicial del directorio de páginas. Los doce bits menos significativos del registro siempre están a cero para que siempre el directorio de páginas esté dentro de una página determinada. La operación de carga mediante la instrucción MOV CR3, reg o bien un cambio de tareas que implique un cambio de valor del registro CR3 hace que se eliminen las entradas de la caché de la tabla de páginas. Registros de test Se utilizan dos registros para verificar el funcionamiento de la CAM8 en el TLB. TR6 es el registro de comando del test, mientras que TR7 es el registro de datos que contiene el dato proveniente del TLB. El TLB guarda las entradas de tabla de página de uso más reciente en una caché que se incluye en el chip, para reducir los accesos a las tablas de páginas basadas en RAM. 8
CAM (Content‐Addressable Memory – Memoria de Contenido Direccionable). Al contrario de las memorias estándar (memorias de acceso aleatorio o RAM) en las que el usuario introduce una dirección de memoria y la RAM devuelve los datos almacenados en esa dirección, una CAM está diseñada de manera que el usuario proporciona los datos y la CAM busca en toda la memoria para ver si esos datos están almacenados en alguna posición. Si los datos son encontrados, la CAM devuelve una lista de una o varias direcciones en las que la información fue encontrada (en algunas arquitecturas, también devuelve los propios datos buscados, u otros tipos de información). Es decir, una CAM es la expresión en hardware de lo que en términos de software se denominaría un array asociativo. 71
PFC: Análisis TLB – Mónica Larruy Carrete Figura 33: Registros TLB TR6 TR6: Registros de comandos TLB. Contiene direcciones virtuales, código/datos seleccionados (CD), operación (OP) y los siguientes bits de estado: válido (V), dirty (D), usuario (U), escritura (W) y tamaño de página (PS). El bit V indica si la entrada en el TLB es válida o no. El bit D muestra si se efectúo un acceso de escritura en la página. El bit U apunta al nivel de privilegios que el procesador debe tener para acceder a la página. El bit W es uno de los factores para determinar la protección de lectura/escritura de la página. El bit PS especifica el tamaño de la página para su entrada en el TLB. El bit CD determina si se accede a datos TLB o bien a comandos. El bit OP distingue entre un ciclo de lectura y uno de escritura. Los bits W, D y PS son definidos únicamente para el TLB de datos. Valores de los bits para TR6 Bit V 0 1 Válido/Inválido Inválido Válido Bit U 0 1 Nivel de privilegios para acceder PL=0,1,2,3 PL=0 Bit PS 0 1 Tamaño de página 4 KBytes 4 MBytes Bit D 0 1 ¿Acceso de escritura a la página? No Sí Bit W 0 1 ¿Permitida escritura? No escrituras, sólo lecturas Permite escrituras Tabla 9: Valores de los bits del registro TR6 de Pentium 72
PFC: Análisis TLB – Mónica Larruy Carrete TR7 TR7: Registros de datos del TLB. En el procesador Pentium (75/90/100/120/133/150/166/200) contiene 31:12 bits de la dirección física, el indicador de acierto (H: hit), dos bits al puntero de entrada y los bits de estado. Estos últimos incluyen los dos bits de atributos de paginación (PCD y PWT), y LRU (3 bits: L0, L1 y L2). Cuando se lee este último campo se obtiene el valor de los tres bits usados en el algoritmo de reemplazo LRU de la caché. El bit PCD (salida de deshabilitación de página de caché) refleja el estado del bit de atributo PCD en la entrada de tabla de páginas o entrada del directorio de páginas. El bit PWT (escritura de página a través de la salida) indica el estado del bit de atributo PWT en la entrada de la tabla de páginas o en la entrada del directorio de páginas. Los bits LRU determinan que entrada deberá ser reemplazada según el algoritmo LRU. En los procesadores Pentium con tecnología MMX, el puntero de entrada pasa de tener dos bits a seis. Éstos determinan cuál de las 64 entradas escribirá en la TLB de datos durante una escritura. Los cinco bits de entrada de menos peso indican cuál de las 32 entradas escribirán en el TLB de comandos durante una escritura. El bit H es el indicador de acierto. Este bit se debe poner a 1 durante una escritura. Mientras que si en una lectura, la entrada a la dirección lineal marca una entrada válida en el TLB, el bit H se modificará con un valor igual a 1. Los dos bits de entrada determinan cuál de las cuatro vías escribirá en el TLB en el proceso de escritura. En la lectura, éstos indicarán la vía que se ha utilizado para leer un bit. TR6 y TR7 son registros lectura/escritura. Registros Los descriptores de la caché y el TLB son proporcionados por los registros EAX, EBX, ECX y EDX después de que la instrucción CPUID sea ejecutada con un 2 en el registro EAX. EAX: Normalmente se le llama "acumulador" puesto que es en él donde se sitúan los resultados de operaciones, tales como DIV y MUL. Su tamaño, al igual que el resto, es de 32 bits. Puede dividirse en dos sub‐registros de 16 bits, uno de los cuales (el menos significativo, es decir, el de la derecha) se puede acceder directamente como AX. A su vez, AX se puede dividir en dos sub‐
registros de 8 bits, AH y AL. EBX: Aquí sucede lo mismo que con EAX; su división incluye subregistros BX (16 bits), BH y BL (8 bits). 73
PFC: Análisis TLB – Mónica Larruy Carrete ECX: Aunque este registro es como los anteriores (con divisiones CX, CH y CL), tiene una función especial que es la de servir de contador en bucles y operaciones con cadenas. EDX: Se puede dividir este cuarto registro "genérico" en DX, DH y DL; además, tiene la característica de que es aquí donde se va a guardar parte de los resultados de algunas operaciones de multiplicación y división (junto con EAX). Se le llama "puntero de E/S", dada su implicación también en acceso directo a puertos. Acceso TLB A diferencia de las cachés, el TLB está estructurado como una celda CAM, por lo que el programador puede leer/escribir directamente una determinada entrada en los datos o comandos de cachés, sin embargo, el TLB sólo indica el acierto o fallo en bit H del TR7. Para escribir una entrada en el TLB: ‐
Escribe la dirección física (31:12 bits), los bits atributo, los bits LRU y la sustitución de la entrada en el TR7. Por lo que el bit H, en el TR7, se deberá poner a 1. ‐
Escribir la dirección lineal, los bits de protección y el tamaño de la página en el TR6. También habrá que establecer, en el TR6, el bit OP a 0. Para leer una entrada del TLB: ‐
Escribir la dirección lineal y los bits CD y OP=1 en TR6. ‐
Si el bit H, del TR7, está a 1, la lectura resulta un acierto. Se lee la dirección física traducida, los bits de atributo, y la entrada del TR7. Leer los bits V, D, U y W del TR6. Ahora bien, Si el bit H se encuentra a 0, la lectura produce un fallo y la dirección física no está definida. Cabe mencionar que en la lectura del TLB, el bit PS en el registro TR6 no tiene porque estar fijado, ya que dicho bit es realmente escrito por el procesador al final de la búsqueda del TLB. Resumen TLB en procesadores Pentium El Pentium dispone de dos cachés internas que son gemelas y se usan para almacenar datos e comandos por separado. Éstas tienen un tamaño de 8 KB, una organización asociativa de 128 conjuntos, con 2 líneas por conjunto y 32 bytes por línea. El algoritmo de reemplazo es LRU (Least Recently Used) y la actualización es directa (write‐through). Además, cada caché dispone de su propio TLB, que dispone de 64 entradas en el caso de los datos y 32 en el de las comandos, ambas organizadas de forma totalmente asociativas. 74
PFC: Análisis TLB – Mónica Larruy Carrete 4.12.5.
Pentinum Pro 4.12.5.1. Introducción El Pentium Pro es la sexta generación de arquitectura x86 de los microprocesadores de Intel, cuya meta era remplazar al Intel Pentium en toda la gama de aplicaciones, pero luego se centró como chip en el mundo de los servidores y equipos de sobremesa de gama alta. Posteriormente Intel lo dejó de lado a favor de su gama de procesadores de altas prestaciones llamada Xeon. Fue puesto a la venta en noviembre de 1995. 4.12.5.2. Características Ofrece soporte para cachés secundarias externas (fuera del chip de la CPU). Usa una caché secundaria de 256 KB ó 512 KB en un chip diferente encapsulado con el procesador. Ello permite reducir el tiempo de acceso a la caché secundaria. Dispone de optimizaciones que permiten reducir la penalización de los fallos. La primera consiste en proporcionar la página pedida cuando ocurre un fallo. También permite que el procesador continúe ejecutando instrucciones que acceden a la caché de datos durante un fallo de caché. Característica Direcciones virtuales Direcciones físicas Tamaño de página Organización del TLB Intel Pentium Pro
32 bits
32 bits
4KB, 4MB
Un TLB para instrucciones y otro para datos. Ambos 4‐asociativos Reemplazo Pseudo‐LRU TLB instrucciones: 32 entradas TLB datos: 64 entradas Fallos del TLB tratados por hardware Tabla 10: Resumen características Intel Pentium Pro 75
PFC: Análisis TLB – Mónica Larruy Carrete 4.12.6.
Core 2 Duo El microprocesador Core 2 Duo de Intel es la continuación de los Pentium D y Core Duo. Su distribución comenzó el 27 de julio de 2006. Mediante la aplicación RightMark Memory Analyzer, he optado por instalarla sobre mi ordenador, para obtener datos interesantes acerca de la caché y el TLB. ‐ Modelo analizado: Intel Core 2 Duo T7100 1.8GHz. ‐ Core: Merom, la primera versión portátil del Core 2, fue oficialmente presentada el 27 de Julio de 2007. 4.12.6.1. Caché Dispone de dos cachés: ‐
En el primer nivel, se encuentra la caché de datos y la de instrucciones. Ambas poseen un tamaño de 32KB y son asociativas por 8 vías. ‐
En el segundo nivel, la caché está integrada por un tamaño de 2048KB, y al igual que la de primer nivel, es asociativa por 8 vías. 76
PFC: Análisis TLB – Mónica Larruy Carrete 4.12.6.2. TLB Cada una de las cachés anteriormente mencionadas dispone de un TLB. Primer Nivel Caché: ‐ TLB Datos, cuenta con 256 entradas, asociatividad de 4 vías y una penalización por fallo de 7 ciclos. ‐ TLB Instrucciones, posee 128 entradas, asociatividad, también, de 4 vías. Pero en este caso, la penalización por fallo es penalizada con muchos más ciclos; 20. Segundo Nivel Caché: ‐ TLB Datos, respecto a la caché de primer nivel, el número de entradas decrece considerablemente, pasando a ser 16. Se mantiene la asociatividad de 4 vías. Y en este caso, la penalización por fallo pasa a ser únicamente de 2 ciclos. ‐ TLB Instrucciones, no se proporciona información al respecto. 77
PFC: Análisis TLB – Mónica Larruy Carrete 4.12.7.
IBM 4.12.7.1. Power­1 Un gran hito de la Arquitectura de Computadores fue la segmentación superescalar, propuesta por John Cocke; acuñó el nombre de superescalar, que consiste en ejecutar muchas instrucciones a la vez en el mismo microprocesador. Los primeros procesadores superescalares fueron los IBM Power‐1. Mientras que el PowerPC es una variación de la arquitectura Power‐1. PowerPC 604 PowerPC (usualmente abreviada PPC) es el nombre original de la arquitectura de computadoras de tipo RISC, fue desarrollada por IBM, Motorola y Apple. El PPC 604, al igual que el Pentium Pro, también ofrece soporte a cachés secundarias externas y optimizaciones adicionales que permiten reducir la penalización de los fallos. El Pentium Pro y el PPC se distinguen en su traducción de direcciones y estas diferencias se trasladan a la circuitería del TLB. El PPC tiene una dirección virtual mayor; 52 bits, frente a los 32 bits del Pentium Pro. Característica Direcciones virtuales Direcciones físicas Tamaño de página Organización del TLB PowerPC 604
52 bits
32 bits
4KB, seleccionable y 256 MB
Un TLB para instrucciones y otro para datos. Ambos 2‐asociativos Reemplazo LRU TLB instrucciones: 128 entradas TLB datos: 128 entradas Fallos del TLB tratados por hardware Figura 34: Resumen de las características del PowerPC 604 Esta máquina permite páginas grandes. Este tipo de páginas evitan que se asignen muchas entradas a un simple objeto que está siempre presente. El PPC también ofrece un tamaño de página variable para permitir el uso de páginas mayores. 78
PFC: Análisis TLB – Mónica Larruy Carrete 4.12.8.
AMD 4.12.8.1. K5 El microprocesador K5 fue elegido por AMD para competir con el Pentium original. Ello tuvo lugar en 1996, y se situaba entre las prestaciones del Pentium y el Pentium Pro. Destacaba por las siguientes características: ‐
Novedoso sistema de predicción de fallos. ‐
Ejecución fuera de orden que no se penalizaba al ejecutar aplicaciones de 16 bits, algo que al Pentium Pro le costó que el mercado le diera la espalda. ‐
Factor de superescalaridad de cuatro (frente a los dos con restricciones en el Pentium). ‐
Una caché L1 de 24 KB, dividida en 16 KB para instrucciones y 8 KB para datos. 4.12.8.2. AMD Athlon: K7 A mediados de 1999, AMD lanzó al mercado el que se ha convertido en el emblema de la compañía: su K7 o Athlon. Figura 35: Diagrama de bloques del microprocesador K7 de AMD, con su sistema de decodificación en paralelo y sus dos cauces de ejecución (uno para enteros y otro para números de coma flotante) 79
PFC: Análisis TLB – Mónica Larruy Carrete A continuación, se pasará a explicar su complejo sistema de decodificación en paralelo, donde como se verá, participa el TLB. 1) Direccionamiento del código. El contador del programa referencia a una posición de memoria virtual que se traduce a dirección física ayudándose de un TLB. Éste presenta una implementación multinivel de 24 y 32 entradas en el primer nivel para instrucciones y datos, y de 256 en el segundo nivel para cada caso. 2) Obtención del código de instrucción. Con la dirección física se accede a la caché de instrucciones, de donde se obtiene el código de instrucción de 128 bits. 3) Predecodificación. El código se pasa a un cauce segmentado DirectPath si éste tiene instrucciones sencillas, sino se pasa a VectorPath. 4) Macrodecodificación. En el primer caso, la decodificación y el control se realiza como en un procesador RISC. Mientras que en el segundo caso, la realiza una ROM de proyección que direcciona a su vez a una ROM de microprograma 5) Microdecodificación. Tres decodificadores de instrucción funcionan en paralelo para traducir individualmente y simultáneamente los códigos de control de cada una de las tres instrucciones que componen el código de 128 bits. Al final de esta etapa, se obtienen las microinstrucciones. Éstas llegan a la unidad de control de instrucción, tienen como objetivo situarse en el cauce segmentado según su tipo: entero o punto flotante. Fase de búsqueda de instrucción A la hora de la ejecución de una instrucción, el K7 realiza la búsqueda de instrucción usando su caché L1I convencional, a la que accede en un solo ciclo a través de su TLB integrada (donde se realiza la traducción virtual a física). Figura 36: Diagrama de bloques del procesador superescalar Athlon de AMD 80
PFC: Análisis TLB – Mónica Larruy Carrete Es capaz de realizar las etapas fetch, decode e issue de hasta tres instrucciones x86 por ciclo, gracias a la unidad de control de instrucciones (UCI) centralizada y también puede tratar dos tipos de instrucciones; enteras o de coma flotante. Instrucciones Caché La memoria caché L1 de instrucciones está formada por 64 KB. Las funciones asociadas con L1 son: instrucciones de carga, instrucciones de prefetch, instrucciones precodificadas y predicciones de salto (branch). Si se pierde una instrucción L1 caché, éstas se cargarán de la L2, o bien a partir de la memoria local, mediante unidad interfaz de bus (BUI). El reemplazo de las líneas de caché se efectúa mediante el algoritmo LRU (algoritmo de reemplazo basado en sustituir aquella que se haya utilizado menos recientemente). La I‐Caché de L1 tiene asociada una estructura TLB a dos niveles. El primer nivel es totalmente asociativo y contiene 24 entradas (16 pueden mapear páginas de 4 KB, y los ocho restantes pueden mapear páginas de 2 ó 4 MB), mientras que el segundo también es asociativo de cuatro vías y posee 256 entradas para mapear páginas de 4 KB. Datos Caché La memoria caché L1 de datos posee dos puertos de 64 KB. Es una caché de tipo write‐back9 (escritura retardada) y usa una política de reemplazo LRU. Los datos e instrucciones de caché son ambos un conjunto asociativo de dos vías y de 64 KB. Se dividen en 8 bancos, donde cada banco es de 8 bytes. Además, esta caché soporta el protocolo MOESI (Modificación, Propietario, Exclusividad, Compartición e Invalidación) de coherencia de caché y paridad de datos. La memoria caché L1 de datos tiene una estructura asociativa TLB de dos niveles. El primer nivel es completamente asociativo y contiene 32 entradas (24 que mapean páginas de KB y las ocho restantes que mapean páginas de 2 ó 4 MB). El segundo nivel del TLB es un conjunto asociativo de 4 vías, con 256 entradas que puede mapear páginas de 4 KB. 9
Write‐back: es la acción de escribir un bloque válido y sucio desde un nivel de la caché al nivel inferior de la jerarquía de memoria (L2, memoria principal) donde también se podría encontrar información de ese bloque pero no está actualizada. 81
PFC: Análisis TLB – Mónica Larruy Carrete AMD K8 Introducción El AMD K8 fue un procesador que marcó una época, arrasó a la competencia de su archirival Intel y se convirtió en el rey en los segmentos de consumo y estaciones de trabajo / servidores. El revolucionario concepto de la controladora de memoria integrada, primicia en el mundo x86, disparó brutalmente las prestaciones del núcleo K8. El K7 siempre adujo de elevadas latencias en su subsistema de memoria, una caché L2 muy lenta y con alta latencia y un hardware prefetch ineficiente con una implementación simplista hacían del AMD Athlon un gran procesador ávido de datos e instrucciones. K8 acabó con la gran limitación de K7 y lo hizo a lo grande. Integró la controladora de memoria en la CPU. TLB La implementación TLB de AMD K8 es la siguiente: ‐
L1 D‐TLB: 32/4 entradas. Completamente asociativo. Miss penalty de 5 ciclos. ‐
L1 I‐TLB: 32/4 entradas. Completamente asociativo. Miss penalty de 4 ciclos. ‐
L2 D‐TLB: 512 entradas. Asociatividad de 4 vías. Miss penalty de 17 ciclos. ‐
L2 I‐TLB: 512 entradas. Asociatividad de 4 vías. Miss penalty de 25 ciclos. Figura 37: Captura con RMMA (RightMark Memory Analyzer) de las características del TLB en un AMD K8 Se puede decir que es una implementación bastante potente. Claramente superior a la de su competidor, el Intel Pentium 4. 82
PFC: Análisis TLB – Mónica Larruy Carrete 4.12.8.3. AMD K10 Barcelona 65nm Implementación TLB en AMD Barcelona: ‐
L1 D‐TLB: 48 entradas. Completamente asociativo. Miss penalty 5 ciclos. ‐
L1 I‐TLB: 48 entradas. Completamente asociativo. Miss penalty 4 ciclos. ‐
L2 D‐TLB: 512 / 128 entradas. Asociatividad 4 vías. Miss penalty 28 ciclos. ‐
L2 I‐TLB: 512 / 128 entradas. Asociatividad 4 vías. Miss penalty 36 ciclos. 4.12.8.4. AMD K10 (AMD Phenom) Los AMD Phenom forman parte de una nueva línea de microprocesadores, denominada AMD K10 (los AMD64 formaban parte de los K8, por ejemplo, y los K9 todavía son un proyecto), y traen muchos modelos con diferentes características: En primer lugar, tres tipos de microprocesadores: ‐
Phenom X2 (codename Kuma): doble núcleo, desde 1.9 hasta los 2.9 GHz, tres niveles de caché (L1:2x(64x64); L2:2x512; L3:2048) y lanzados aproximadamente sobre el último cuarto del 2007. En teoría, la gama más baja de los tres tipos. ‐
Phenom X4 (codename Agena): microprocesadores quad‐core, desde 1.9 hasta los 2.5 GHz, tres niveles de caché (L1:4x(64x64); L2:4x512; L3:2048) y fueron lanzados aproximadamente en junio de 2007. ‐
Phenom FX (codename Agena FX): también quad‐core, desde 2.4 hasta los 2.6 GHz, y también tres niveles de caché (L1:4x(64x64); L2:4x512; L3:2048). Se lanzaron junto con los Phenom X4. Vienen a ser la gama más alta de microprocesadores domésticos AMD, más que los X4. Como característica común Todos los Phenom tienen tecnología de 65 nanómetros y utilizan el socket AM2+ (cuya principal novedad es la integración de la última versión de HyperTransport10, la 3.0), excepto los Phenom FX que utiliza el Socket F o el F+ (el mismo que algunos Opteron). Adicionalmente, AMD también lanzó a finales de 2007, y dentro de su gama de microprocesadores K10 los Barcelona (es su sobrenombre), que serán los sucesores de los Opteron en los K8, los actuales micros para servidores. AMD Barcelona es un microprocesador de cuatro núcleos nativos. Con estos K10 AMD Barcelona: 2 MB de memoria caché L3 compartida y 512 KB de caché L2 para cada núcleo. 10
HyperTransport: es un bus de interconexión punto a punto pensado para reemplazar a la extensa jerarquía de buses multinivel del PC, aunque está dirigida a todo tipo de plataformas, incluyendo servidores y sistemas empotrados. 83
PFC: Análisis TLB – Mónica Larruy Carrete Instruction Fetch: es una pequeña memoria que actúa como buffer en el momento de cargar información desde la L1 para la decodificación y posterior ejecución. En el K8 y Core 2 esa memoria era capaz de almacenar hasta 16 bytes por ciclo, en el caso del K10 esa memoria ha aumentado al doble, 32 bytes, para asegurar una ejecución mantenida de instrucciones lo más cercano a 3 instrucciones por ciclo. Tabla 11: Comparativa de la capacidad TLB entre AMD K8 y AMD K10 Las mejoras en el apartado de virtualización se deben en gran parte a la mejora y ampliación de los buffers TLB que manejan estos procesadores, donde el K10 ha aumentando notablemente la capacidad de éstas agregando soporte a páginas de 2MB y 1GB, sin embargo, estas mismas modificaciones son las que le han traído problemas a AMD y el bug TLB de la revisión B2 de los primeros Phenom‐Barcelona. 84
PFC: Análisis TLB – Mónica Larruy Carrete 5. HERRAMIENTAS UTILIZADAS 5.1. SimpleScalar SimpleScalar es un simulador de arquitectura de computadores, desarrollado por la universidad de Wisconsin. Gracias a que la herramienta se distribuye en código abierto, desde 1995, se encuentra ampliamente difundido y respaldado por una gran comunidad de usuarios que participan de forma activa en su desarrollo y mejora. A su vez, permite a los usuarios ampliar SimpleScalar, y adaptar los modelos existentes con sus propias ideas. Las herramientas del SimpleScalar permiten a los usuarios construir aplicaciones que simulan verdaderos programas, pudiéndose ejecutar en una amplia gama de procesadores modernos y sistemas. A parte de usarse para la simulación, se incluye un conjunto de herramientas de visualización de rendimiento, análisis estadístico de los recursos, y de depuración y verificación de la infraestructura. 5.1.1. Funcionamiento A la hora de realizar las simulaciones toma un binario compilado para su arquitectura, emulando su ejecución sobre uno de los cinco procesadores simulados que facilita. Esta herramienta ya contiene binarios precompilados que se pueden utilizar, pero a su vez, provee de una versión modificada del GNU GCC, para poder compilar nuestro propio test en FORTRAN o C. 5.1.2. Características ‐
Alta flexibilidad: simulador funcional (implementa la arquitectura) + simulador de rendimiento (implementa la microarquitectura) ‐
Portabilidad: o
Requiere sólo que las herramientas GNU estén instaladas en la máquina. o
Se puede ejecutar sobre diferentes sistemas operativos, aunque la mayoría de los usuarios utilizan Linux/x86. o
Puede interpretar diferentes conjuntos de instrucciones: el Alpha (DEC, Digital Equipment Corporation), PISA (Portable Instruction Set Architecture), ARM (Advanced RISC Machines Ltd.) y del x86 (Intel). 85
PFC: Análisis TLB – Mónica Larruy Carrete o
Se puede ejecutar en diversas plataformas, desde procesadores unpipelined a microarquitecturas con planificaciones dinámicas y múltiples niveles de jerarquía. ‐
Extensibilidad: modelo estructurado que permite realizar modificaciones de forma más fácil de un cierto modelo. ‐
Rendimiento: o
Sim‐Fast: 10+ MIPS (Millones de Instrucciones Por Segundo) o
Sim‐Outorder: 350+ KIPS 5.1.3. Modalidades de simulación Figura 38: Modalidades de simulación integradas en SimpleScalar 1)
Sim‐Fast: es la simulación más rápida y sencilla. Se encarga de realizar una emulación funcional, ejecutando instrucciones en serie, sin tener en cuenta la caché, el comportamiento de los pipelines, ni ninguna otra parte de la microarquitectura. Cabe mencionar que la única modalidad que no soporta es DLite! 2)
Sim‐Safe: no es más que una variante del anterior, pero algo más lento, ya que realiza comprobaciones de permiso de acceso a memoria en cada operación. 3)
Sim‐Profile: controla y devuelve contadores de instrucciones dinámicas, contadores de tipo de instrucción, contadores de salto y modos de direccionamiento. 4)
Sim‐Caché / Sim‐Cheetah: simulador de la caché del procesador. Es perfecto para simulaciones rápidas de caché, siempre y cuando el efecto del funcionamiento de la misma sobre el tiempo de ejecución no se requiera. Emula diferentes niveles, tamaños y organizaciones de memorias de caché, tanto de datos como de instrucciones. 5)
Sim‐BPred: simulador de predicciones de salto, donde se emulan diferentes tipos de pronósticos, devolviendo aciertos de predicción (hits) o bien fallos (misses). 86
PFC: Análisis TLB – Mónica Larruy Carrete 6)
Sim‐Outorder: de todos los simuladores mencionados, es el más complejo. Éste es capaz de realizar la emisión y ejecución fuera de orden mediante RUU (Register Update Unit). Este tipo de registro usa un buffer de reordenación para renombrar de manera automática los registros y mantiene los resultados de direcciones pendientes. Este simulador está muy parametrizado, dispone de la posibilidad de especificar el tipo de predicción de salto (taken, nottaken, BTB con contador de dos bits, etc), se puede activar la
herramienta para el trazo del pipeline, etc. Por último, mencionar que puede emular procesadores con varias unidades de ejecución.
5.2. CACTI 5.2.1. Introducción El simulador CACTI es una herramienta utilizada para evaluar las estructuras de memoria implementadas en un microprocesador, así como también se usa la función de simulador de temperatura y de energía. Concretamente para este proyecto, se aplicará para el estudio estático de las memorias cachés; área, consumo y tiempo acceso. En 1994, surgió la primera versión de CACTI (CACTI 1.0), con ello se consiguió una rápida herramienta para modelar cachés SRAM. Se encargaba de contabilizar el tiempo de acceso y de ciclo entre la configuración de la memoria caché directa y la asociativa. Posteriormente se amplió a la versión CACTI 2.0. En ella se proporcionaba soporte a las memorias cachés completamente asociativas, configuración multipuerto y al tamaño de línea. En ésta ya se tenía en cuenta el consumo generado por una cierta configuración. En la versión 3.0, se añadió soporte para los subbancos. Éstos permiten dividir la memoria caché en un número de subbancos que poseen su propio conjunto de direcciones y buses de datos. Tras ésta, surgió la versión 4.0. En ella se añade un modelo para leakage power y se actualiza la estructura básica de circuitos y los parámetros de los dispositivos para reflejar los avances en la ampliación de semiconductores desarrollados en los últimos años. Finalmente, actualmente se cuenta con la versión CACTI 5.1. Ésta incluye mejoras respecto a la anterior versión, principalmente destacan las siguientes: a)
La tecnología de modelado ha cambiado la escala lineal simple de la tecnología de 0.8 micrones a modelos basados en ITRS. 87
PFC: Análisis TLB – Mónica Larruy Carrete b)
La implantación de la tecnología DRAM ha sido establecida por algunos proveedores. Por ello, se ofrece soporte de modelado de memorias DRAM. c)
Permite a los usuarios ejercer más control sobre el área, el delay y la potencia de la solución final. La versión utilizada en este proyecto es la 4.1. Ya que si bien HP dispone de la versión 5.3 online, ésta no satisface las necesidades que plantea tamaños tan pequeños como los de un TLB. El hecho de decantarse por una versión anterior a la actual, es debido principalmente a que la última versión de CACTI, supone unos parámetros de entrada, tales como: temperatura, tipo de dispositivo de circuito tanto para el array de TAGs como para el de datos, ancho de banda del TAG, etc. los cuales son absolutamente irrelevantes para nuestro estudio. Por su parte, la versión 4.1 acepta como entrada: tamaño TLB, tamaño de línea, asociatividad, tecnología integración, número de puertos L/E, número de puertos de lectura, número de puertos de escritura y número de subbancos. Por lo que adaptando este conjunto de valores de entrada se realizarán los posteriores estudios. 5.2.2. Funcionamiento CACTI usa varios modelos analíticos para calcular el tiempo de acceso, el área y la energía consumida para diferentes configuraciones de la memoria caché. El simulador CACTI devolverá la mejor configuración en relación con el tiempo de acceso, la energía consuma y el área a partir de una función de optimización. 88
PFC: Análisis TLB – Mónica Larruy Carrete 6. ESTUDIO ESTÁTICO CON CACTI 6.1. Introducción CACTI divide la memoria caché, en dos: una para direcciones (Tag Array) y otra para datos (Data Array). Figura 39: Estructura caché usada en CACTI En la figura 39 se puede apreciar el Tag Array (array de etiquetas), el cual indica a que porción de la RAM está asociada cada línea de la caché. Es decir, permite traducir una dirección de RAM en una determinada línea de caché. El decodificador (figura 39) inicialmente decodifica la dirección y selecciona la fila adecuada haciendo conducir una línea de palabra en el array de datos y una línea de bit en el array de etiquetas. Cada array contiene tantas líneas de palabras como filas haya en dicho array, pero sólo una de ellas se activa a la vez. Cada celda de memoria a lo largo de la fila seleccionada tiene asociada un par de líneas de bit. Cuando la línea de palabra se activa, cada celda de memoria en esa fila descarga una de sus dos líneas de bit; el valor almacenado en la celda de memoria determina que línea de bit se descarga. Cada amplificador monitoriza un par de líneas de bit y detecta cual de las dos cambia. Detectando cual de las dos líneas cambia el amplificador determina que valor existe en la celda. Es posible compartir un amplificador entre varios pares de líneas de bit. En ese caso, se inserta un multiplexor antes del amplificador; las líneas de selección son dirigidas por el decodificador. 89
PFC: Análisis TLB – Mónica Larruy Carrete La información leída del array de etiquetas se compara con la etiqueta obtenida de la dirección. En una caché de asociatividad k se requieren k comparadores. El resultado de las k comparaciones se utilizan para indicar si ha habido un acierto (cache hit) o un fallo (cache miss) en caché, en este último caso el dato debe ser traído de la memoria principal. Para conducir las líneas de selección de los multiplexores de salida. Estos multiplexores seleccionan la información apropiada del array de datos (en una caché asociativa o en una en el que el ancho del array de datos es mayor que el ancho de salida), y conducen la información fuera de la caché. El hecho de disponer de cachés separadas presenta: ‐
Ventajas: a) Tener cachés separadas evita colisiones entre la etapa de traída y la de acceso a los datos. b) Se consigue duplicar el ancho de banda (dos accesos en paralelo). ‐
Desventajas: por separado pueden llegar a tener mayores tasas de fallos que unificadas. 6.2. Resultados extraídos A partir de CACTI se ha obtenido: ‐
Tiempo de acceso Æ establece el tiempo de acceso total mediante Access Time (ns). El tiempo de acceso es calculado como el peor tiempo de acceso al TLB, ya que CACTI lo separa en el tiempo de acceso al Data array y el tiempo de acceso al Tag array. Así pues, si ocurre que el tiempo de acceso al array de datos es superior al del array de TAGs, es decir (T. acceso Datos) > (T. acceso TAG), implicaría que el tiempo de acceso resultante devuelto por CACTI sería el de datos. También puede suceder lo contrario; (T. acceso TAG) > (T. acceso Datos). En este caso, el resultado obtenido sería el tiempo de acceso al array de TAGs. En el Tag array se realiza una comparación para averiguar si a partir de una cierta dirección contiene una determinada línea de caché. Por su parte, en el Data array no se efectúa ninguna comparación. Este hecho junto con el pequeño tamaño de línea permitido en el almacenamiento de TLBs, hace pensar que el mayor tiempo de acceso se produzca en el Tag array. 90
PFC: Análisis TLB – Mónica Larruy Carrete ‐
Área Æ indica el área total que ocupan todos los bancos del TLB mediante Total area subbanked (mm2). ‐
Consumo Æ CACTI proporciona dos valores de consumo. Por un lado estaría el consumo producido por las lecturas; Total dynamic Read Energy all Banks (nJ), y por otro el generado por las escrituras; Total dynamic Write Energy all Banks (nJ). Generalmente, cuando se mide el consumo de una caché (en el estudio se tratará de un TLB) se toma el resultado generado por la operación de lectura, ya que por cada cuatro lecturas suele realizarse una escritura, tomando así la operación más frecuente; la de lectura. Para conseguir un completo estudio se ha considerado interesante analizar ambos consumos, adjuntando también una comparativa entre éstos. 6.3. Modificaciones CACTI Para el estudio estático (área, consumo y tiempo acceso) se ha empleado, tal como se ha comentado, el simulador CACTI. Aunque han sido necesarias una serie de modificaciones sobre el propio código de CACTI. 6.3.1. Independizar resultados El enfoque tomado por CACTI, consiste en obtener el mejor resultado, iterando todas las posibles configuraciones, en relación a los tres parámetros que se estudiarán (tiempo de acceso, área y consumo). Para ello se basa en la siguiente función de optimización: 1
Así pues, para realizar los estudios del tiempo de acceso, se debe valorar la solución asociada únicamente al efecto que produce dicho tiempo, omitiendo con ello la solución que también proporcionaría el área y la energía. Para ello bastaría con considerar c1=1 y el resto=0. Lo mismo ocurre para el caso de querer analizar el efecto del área o el consumo. Donde sólo se tendrán en cuenta el parámetro asociado a cada uno de ellos, c2 y c3 respectivamente. 91
PFC: Análisis TLB – Mónica Larruy Carrete 6.3.2. Eliminar restricciones de tamaño del TLB Uno de los principales problemas surgidos es que, CACTI no ha sido diseñado para el estudio de memorias de tamaño tan pequeño como llega a ser un TLB. Dicha circunstancia se debe a que CACTI define el número de filas por subarray mediante la siguiente expresión: C
B A N
N
siendo C= tamaño caché (en el estudio, tamaño TLB), B= tamaño de línea y A= grado de asociatividad. Tal como formula CACTI, la expresión anteriormente indicada debe ser mayor que cero. Condición que no ocurre con valores de TLB pequeños. Por ejemplo, con un tamaño de 1024 bytes (el mínimo estudiado), se obliga a: A≤4 o B≤64 o a bien aumentar C. Ninguna de estas tres necesidades son posibles para efectuar el estudio deseado. Así pues, es necesario saltarse las restricciones establecidas. Ello implica la modificación del fichero area.c, concretamente las funciones:
y
data_organizational_parameters_valid
tag_organizational_parameters_valid. Con ello se consigue aceptar tamaños pequeños de TLB. También será necesario poder saltar los errores que provoca tener un número de subbancos menor que cero. Para ello también se ve afectado el fichero area.c, pero esta vez las funciones afectadas son: decodemem_row, postdecode_area, decodetag_row y fadecode_row. Y el fichero time.c, en concreto se trata de las funciones decoder_delay, decoder_tag_delay. Para poder estudiar tamaños de TLB tan pequeños como suponían 512 y 256 bytes se vio también modificado el fichero io.c. En este se eliminaron todas aquellas restricciones asociadas que no permitían trabajar con tamaños de caché tan pequeños. Aunque tal como se menciona en el apartado de los parámetros y valores estudiados, estos valores fueron finalmente suprimidos. 6.3.3. Modificar mínimo de escala de integración De cara al tratamiento de la escala de integración, se optó por poder estudiar versiones de hasta 90 nanómetros (nm). Pero en la versión empleada de CACTI, sólo se permite hasta 80 nm. Así pues, se modificaron dos ficheros. Se trata de io.c, para cambiar aquellas partes en las que únicamente se permitía introducir como máximo 80 nm por 90. Y del fichero leakage.c. Una de las funciones que posee éste, calcula las energías dinámicas de lectura y escritura, las cuáles son añadidas en el cálculo de la función de minimización de cara a la parte del consumo. Este fichero contiene una serie de funciones, alguna de las cuales es invocada desde time.c, a la hora 92
PFC: Análisis TLB – Mónica Larruy Carrete de realizar el cálculo del tiempo de acceso. Para conseguir una correcta invocación, en el fichero
leakage.c se han visto afectados parámetros tales como Leff y FUDGEFACTOR, los cuales se basaban en 80 nm. 6.4. Parámetros y valores estudiados Mediante CACTI se han efectuado un conjunto de pruebas, donde se ha analizado como afecta al TLB la modificación de los siguientes parámetros: ‐
Tamaño TLB: {256, 512, 1024, 2048, 4096, 8192, 16384, 32768 bytes} ‐
Grado de asociatividad: {directa, 2, 4, 8} ‐
Tamaño de línea: {32, 64, 128 bytes} ‐
Escala de integración: {32, 45, 65, 90 nm} ‐
Número de puertos: {L=1 E=1, L=2 E=1, L=2 E=2, L=4 E=1} Para cada uno de ellos, se obtendrá el tiempo de acceso (Access Time), el área (Total area subbanked) y el consumo (Total dynamic Read Energy all Banks y Total dynamic Write Energy all banks). En el conjunto de pruebas realizadas, se han considerado como comunes los siguientes valores base: ‐
Tamaño TLB: 4KB ‐
Asociatividad: 4 ‐
Tamaño línea: 64 ‐
Escala integración: 45 ‐
Puertos: 2 de lectura, 1 de escritura y 0 de lectura y escritura ‐
Número de subbancos: 1 93
PFC: Análisis TLB – Mónica Larruy Carrete 6.4.1. Estudio del grado de asociatividad Antes de pasar a evaluar los resultados obtenidos, cabe mencionar que debido a restricciones implantadas por CACTI, se hace imposible evaluar TLBs inferiores a 1 KB, ya que todo y evitando la restricción que marcaba como mínimo este tamaño, los resultados generados para 512 y 256 bytes se han descartado por motivo de las incongruencias que resultaban. Así pues el tamaño mínimo estudiado será 1 KB. 6.4.1.1.
Tiempo de acceso Los resultados adjuntos de la figura 40, muestran el tiempo de acceso para diferentes tamaños de TLB, considerando para cada uno de ellos los siguientes grados de asociatividad: directa, 2‐asoc, 4‐asoc y 8‐asoc. Para este análisis sólo se ha ido variando el campo de la asociatividad del TLB en función de los diferentes posibles tamaños de TLB (1, 2, 4, 8, 16 ó 32 KB), manteniendo así fijos el resto de ellos. a) b) Figura 40: Tiempo acceso en función del grado de asociatividad Observando la figura 40 a), se puede apreciar como el tiempo de acceso, en los casos extremos, toma valores desde 2.54822 hasta 3.77207 ns. Por lo que los diferentes grados de asociatividad no reflejan considerables mejoras entre utilizar un tipo u otro, ya que la diferencia entre el valor máximo y el mínimo varía en poco más de un nano segundo. En la figura 40 b) se refleja que a partir del primer tamaño de TLB hasta el último analizado, el tiempo de acceso se mantiene prácticamente constante entre estos valores. Para el caso de tratarse de una asociatividad directa, se observa como el tiempo de acceso en función de la variación del tamaño del TLB, varía de media en poco más de 0.1 ns entre uno y el 94
PFC: Análisis TLB – Mónica Larruy Carrete inmediatamente siguiente. El mayor aumento se produce al pasar de un TLB de 8192 a uno de 16384 bytes. Por su parte, si se dispone de 2‐asoc, 4‐asoc o bien 8‐asoc, se aprecia que el paso de un TLB de 1KB a uno de 2KB, no produce prácticamente ninguna diferencia en el tiempo de acceso. Muestra de ello es que la variación es de poco más de 0.01 ns. En la figura 40 b), se distingue claramente como la asociatividad directa es la que produce mejores tiempos de accesos. A su vez, se trata de la asociatividad que más diferencias experimenta entre un tamaño de TLB y otro. Para el resto de grados de asociatividad, se percibe un comportamiento en el crecimiento similar entre las tres. Ya que si bien para TLBs de hasta 4 KB, la mejor opción (sin considerar la 1‐asoc) sería la 2‐asoc, a medida que se aumenta el tamaño del TLB, llegan a producirse tiempos muy similares. Un ejemplo de ello, sería el caso de disponer de un TLB de 8 KB, donde las tres asociatividades prácticamente coinciden en el mismo tiempo de acceso. Como conclusiones, se puede se extraer que el tiempo de acceso se verá aumentado por el incremento en el grado de asociatividad. Y como era de esperar, un TLB mayor tendrá un tiempo de acceso mayor. 6.4.1.2.
Área El grado de asociatividad no influirá notablemente en el área. Muestra de ello es la figura 41 a) y b). En ellas, los diferentes grados de asociatividad experimentan prácticamente la misma progresión, es por ello que entre un grado de asociatividad y el inmediatamente siguiente, existe de media un crecimiento de unos 2 mm2. Fijándonos en los grados de asociatividad, la mayor diferencia que se alcanza es de aproximadamente 178.5 mm2, con un TLB de 32 KB. Mientras que la mínima diferencia experimentada se encuentra en TLBs de 1 KB, donde sería de poco más de 4.5 mm2. Por su parte, observando el tamaño de TLB se aprecia que entre un cierto tamaño de TLB y el siguiente se sufre un crecimiento de prácticamente el doble, consiguiendo así una evolución exponencial. 95
PFC: Análisis TLB – Mónica Larruy Carrete a) b) Figura 41: Área en función del grado de asociatividad 6.4.1.3.
Consumo lectura a) b) Figura 42: Consumo lectura en función del grado de asociatividad Un TLB con asociatividad directa es claramente el que menor consumo realiza en todos los tamaños de TLB estudiados. Por su parte, disponer de un TLB 8‐asociativo puede llegar a suponer un leve aumento en el consumo de lectura. Las figuras 42 a) y 42 b) muestran como el grado de asociatividad no afecta al consumo de lectura, ya que la evolución que se experimenta es prácticamente lineal para todas las asociatividades estudiadas. Únicamente se diferencia, mínimamente, el grado 8‐asociativo al pasar de un TLB de 1 KB a 2 KB. 96
PFC: Análisis TLB – Mónica Larruy Carrete 6.4.1.4.
Consumo escritura a) b) Figura 43: Consumo escritura en función del grado de asociatividad Al igual que para el consumo de lectura, la asociatividad directa es la que menor consumo experimenta. En las figuras 43 a) y 43 b) se aprecia que el consumo de escritura no se ve afectado por el grado de asociatividad, debido a que el crecimiento es prácticamente lineal para todas las asociatividades estudiadas. 6.4.1.5.
Comparativa: Consumo lectura vs consumo escritura Figura 44: Comparativa consumo en función del grado de asociatividad Si bien cabía esperar que la evolución experimentada del consumo de escritura en comparación con el de lectura fuese unas cuatro veces inferior, ya que por cada escritura se suelen realizar unas cuatro lecturas, en la figura 44 se muestra como es de prácticamente la mitad. 97
PFC: Análisis TLB – Mónica Larruy Carrete También se hace evidente que a menor grado de asociatividad, tal y como se podía intuir, menor será el consumo (tanto de lectura como de escritura). Cabe destacar la poca diferencia existente entre el uso de una asociatividad directa y una asociatividad con dos conjuntos, no ocurriendo igual para el resto de casos, donde la diferencia es más remarcada. 6.4.2. Estudio del tamaño de línea 6.4.2.1.
Tiempo de acceso La entidad básica de almacenamiento la conforman las filas, llamados también líneas de caché. Para el estudio de éstas, se ha optado por evaluarlo con los valores de 32, 64 y 128 bytes. Si bien en el estudio anterior, el parámetro de entrada que variaba era el grado de asociatividad, en este caso la modificación se irá produciendo sobre el tamaño de línea en función de los posibles tamaños de TLB especificados. a) b) Figura 45: Tiempo de acceso en función del tamaño de línea En el estudio de la asociatividad se mencionó que la variación del tiempo de acceso entre los casos extremos era de poco más de un ns. En este caso no se llega a alcanzar ni los 0.4 ns. Para pequeños TLBS el hecho de tener que escoger entre uno de los tamaños de línea estudiados, sería bastante irrelevante, ya que el tiempo de acceso es muy similar. A medida que va incrementando el tamaño del TLB, se aprecia claramente, en la figura 45 b), que líneas de 128 bytes serían la mejor opción. Aunque la diferencia no es considerablemente notable, ya que se trataría de una mejora de media de unos 0.23 ns respecto a una de 32 bytes, y de aproximadamente 0.1 ns en relación con una de 64 bytes. 98
PFC: Análisis TLB – Mónica Larruy Carrete El motivo por el que con un mayor tamaño de línea se consigue el mejor resultado es como consecuencia del hecho del procesamiento de las mismas. Es decir, cuanto mayor sea la línea más bytes se podrán procesar en un mismo ciclo, y con ello menor será el tiempo de acceso al TLB. Al igual que ocurría en el anterior análisis, a medida que aumente el tamaño de TLB también crecerá el tiempo de acceso. 6.4.2.2.
Área a) b) Figura 46: Área en función del tamaño de línea De forma similar que ocurriría en la figura 41 (área en función del grado de asociatividad), los diferentes tamaños de línea no afectan al área. Tal como se puede apreciar tanto en la figura 46 a) como en la 46b), donde para cada tamaño de línea para un mismo tamaño de TLB, el área es prácticamente la misma. 6.4.2.3.
Consumo lectura a) b) Figura 47: Consumo lectura en función del tamaño de línea A partir de la figura 47 a) y b), se aprecia claramente que a mayor tamaño de línea, mayor será el consumo por lectura generado. 99
PFC: Análisis TLB – Mónica Larruy Carrete Cabe destacar, que ya sea entre el tamaño de línea y su inmediatamente siguiente, o bien a partir de un cierto tamaño de TLB y el siguiente a éste, la evolución tiende a ser lineal. La mayor diferencia existente, todo y ser mínima, se encuentra al disponer de un tamaño de línea 128 bytes y pasar de un TLB de 1 KB a uno de 2 KB. 6.4.2.4.
Consumo escritura a) b) Figura 48: Consumo escritura en función del tamaño de línea Al igual que ocurría en la figura 47, el consumo de escritura también crece con el aumento del tamaño de línea. Para los tres casos estudiados de tamaño de línea, la evolución que se sigue en el consumo de escritura es prácticamente la misma. Para los diferentes tamaños de TLB, la diferencia existente entre el mínimo y el máximo varía en poco más de 1 nJ. 6.4.2.5.
Comparativa: consumo lectura vs consumo escritura Figura 49: Comparativa consumo en función del tamaño de línea La figura 49 refleja el contraste existente en los valores máximos que se llegan a obtener entre el consumo de lectura y el de escritura. 100
PFC: Análisis TLB – Mónica Larruy Carrete La mayor de estas diferencias se puede observar para el caso de un tamaño de línea de 128 bytes. Para éste, la diferencia máxima se refleja en un TLB de 32 KB. Se puede apreciar que el consumo de escritura alcanza unos valores máximos muy pequeños. Éstos son inferiores, aproximadamente la mitad, a los que se llegan a adquirir con el consumo de lectura. Se podría decir que los máximos del consumo de escritura son prácticamente los valores mínimos de lectura. El consumo de lectura presenta variaciones pero no son tan remarcadas como con el consumo de escritura. A partir del primer valor mínimo estudiado; 1 KB, se puede apreciar como el consumo que se genera pasa a crecer de forma exponencial. 6.4.3. Escala de integración La escala de integración se indica en nanómetros11 y a menor número, mayor cantidad de transistores en el mismo espacio, es decir, más juntos están. Para realizar el análisis, se ha optado por utilizar los valores más comunes implantados; 90, 65 y 45 nm. Incluyendo también 32 nm, el cual podría ser el siguiente paso que se tome para la reducción de la escala de integración. Con el cambio de 90 a 65 nanómetros se consiguió una mayor densidad de transistores por unidad de superficie en el microprocesador. Al tener un mayor número de estos elementos, el microprocesador gana potencia y mejora la disipación del dispositivo utilizando la misma superficie. Otra opción es, manteniendo la potencia de una CPU, reducir su espacio ocupado. Algo a tener en cuenta es la reducción de la tecnología de 90 a 45 nanómetros, lo que supone la mitad de espacio y, en la teoría, las mismas prestaciones. Actualmente, la escala de integración se encuentra ya en los 45 nm. Considerando, que fue en 2006 donde se empezaron a introducir ordenadores de 65 nm, tales como Intel Core 2 Duo12, no es difícil pensar que en un par de años se pueda llegar a alcanzar una reducción de la escala actual de integración. De allí, que se haya realizado el estudio de 32 nm. 11
Nanómetro: unidad de medida del sistema métrico que equivale a una billonésima parte de un metro, o una millonésima de milímetro. 12
Intel Core 2 Duo de 65 nm, disponía de 291 millones de transistores. Mientras que su versión actual de 45 nm, cuenta ya con 410 millones de transistores. 101
PFC: Análisis TLB – Mónica Larruy Carrete 6.4.3.1.
Tiempo de acceso a) b) Figura 50: Tiempo de acceso en función de la escala de integración A partir de la figura 50 a) y b), a primera vista se aprecia una ligera disminución del tiempo de acceso a medida que la escala de integración también se ve reducida. Tomando como referencia el tamaño de TLB, la mayor mejora se obtiene con la reducción de 32 a 16 KB. Todo y no ser una gran disminución (aproximadamente 0.2 ns), teniendo en cuenta el progreso que se sigue con el resto, si que cabe destacarla. Por su parte, la disminución de 16 KB a 8 KB obtiene aproximadamente el mismo decrecimiento que de 32 a 16 KB. Para cualquiera de las cuatro escalas de integración representadas, no se produce un cambio significativo en el tiempo de acceso con el progresivo decremento del tamaño de TLB de 4 KB hasta alcanzar el tamaño de 1 KB, ya que el tiempo de acceso es prácticamente el mismo. Ahora bien, si se fijan las escalas de integración y observamos las evoluciones experimentadas para cada uno de los tamaños del TLB, destaca la mayor mejora al reducir de 65 a 45 nm, y no como cabría esperar de 90 a 65 nm. Para esta última, se produce una disminución en el tiempo de acceso de media entorno a 1.2 ns, mientras que al pasar de 65 a 45 nm, se consigue una mejora de media de 1.45 ns. Por su parte, el posible descenso de 45 a 32 nm, generaría únicamente un 1 ns de mejoría. 102
PFC: Análisis TLB – Mónica Larruy Carrete 6.4.3.2.
Área A diferencia de los anteriores estudios del área (en función del grado de asociatividad y del tamaño de línea), la escala de integración influenciará en el área. a) b) Figura 51: Área en función de la escala de integración El área, al igual que ocurría con el estudio del tiempo de acceso (figura 50), para tamaños desde 1 hasta 4 KB sigue un crecimiento prácticamente lineal, con valores muy similares entre ellos. Estudiando las figuras 51 desde el tamaño del TLB, despunta el aumento de 8 a 16 KB y de 16 a 32 KB. Si bien para una escala de integración de 32 ó 45 mm2, se sigue un crecimiento lineal hasta alcanzar un tamaño de 4 KB, no ocurre igual para una escala de 65 ó 90 mm2, ya que en éstas se comienza a experimentar el crecimiento a partir de 1 KB. Desde la perspectiva de la escala de integración, la que experimenta aumentos más significativos es la de 90 nm. Pasando de unos 19 mm2 con un TLB de 1 KB hasta 180 mm2 con uno de 32 KB. Es decir, se produce un incremento de 161 mm2. El cual destaca en comparación con el resto. Ya que con 65 nm, se lograría aproximadamente la mitad. Al igual que ocurriría con 45 y 32nm, los cuales conseguirían aumentar únicamente la mitad, en comparación con la escala de integración inmediatamente superior analizada. Como era de esperar, a mayor escala de integración más separados se encontrarán los transistores entre sí, y mayor será el área necesaria. Esto hace evidente que si se desea lograr un claro aprovechamiento del espacio hay que recurrir a escalas de integración cada vez más pequeñas. 103
PFC: Análisis TLB – Mónica Larruy Carrete 6.4.3.3.
Consumo lectura Observando la evolución de la figura 52 a) y b), destaca que a mayor escala de integración (y a mayor tamaño de TLB) más notable será el consumo de lectura generado. a) b) Figura 52: Consumo lectura en función de la escala de integración El aumento que se produce entre una escala de integración y la siguiente es de prácticamente el doble. Este hecho no se refleja entre un tamaño de TLB y su sucesor para una misma escala de integración, ya que se sigue un crecimiento muy lineal. La excepción, mínima, se encontraría para una escala de integración de 90 nm al pasar de un TLB de 16 KB a uno de 32 KB. 6.4.3.4.
Consumo escritura La progresión seguida en la figura 53 es muy similar a la de la figura 52. Únicamente difieren en los valores alcanzados. Pero aquí también evolucionaban en prácticamente el doble, entre una escala de integración y la siguiente. Todo y que existen casos, como sería la escala de 32 y 45 nm, donde ello no ocurre. a) b) Figura 53: Consumo escritura en función de la escala de integración 104
PFC: Análisis TLB – Mónica Larruy Carrete 6.4.3.5.
Comparativa: consumo lectura vs consumo escritura Figura 54: Comparativa consumo en función de la escala de integración A diferencia de las anteriores comparativas (figuras 44 y 49), en ésta se refleja claramente como la escala de integración influencia sobre el consumo tanto de lectura como de escritura, ya que la evolución deja de ser tan lineal como lo era en los otros casos. Aunque se continúa manteniendo que el consumo generado de escritura es aproximadamente la mitad que el de lectura. 105
PFC: Análisis TLB – Mónica Larruy Carrete 6.4.4. Puertos lectura y escritura En este estudio se examinarán diferentes combinaciones del número de puertos, considerando siempre que el número de puertos destinados a lectura y escritura es cero. Esto se debe a que el TLB puede llegar a tener más de un puerto (como los tiene el banco de registros) permitiendo así más de un acceso al mismo bloque del TLB. 6.4.4.1.
Tiempo de acceso El número de puertos de lectura y escritura no afectará al tiempo de acceso. Ejemplo de ello es la figura 49 a) y b), donde el crecimiento es prácticamente lineal. a) b) Figura 55: Tiempo de acceso en función del número de puertos de lectura y escritura El mayor crecimiento se experimenta para L=4 y E=2, donde se obtiene una diferencia de 1 ns entre el menor y el máximo tamaño de TLB. Para el resto de números de puertos, la diferencia se reduce a medida que disminuye el número de puertos. Para TLBs desde 1 a 4 KB, a penas se experimenta una evolución en los diferentes puertos. Es a partir de TLBs de 8 KB donde se empiezan a apreciar, pero siendo aún así mínimos estos cambios. 106
PFC: Análisis TLB – Mónica Larruy Carrete 6.4.4.2.
Área a) b) Figura 56: Área en función del número de puertos de lectura y escritura Con el incremento del número de puertos y del tamaño del TLB, se produce un claro aumento del área total del TLB. Observando el tamaño del TLB, se aprecia en la figura 56 a) y b) un crecimiento exponencial. Y al igual que en el anterior estudio, la mayor subida se produce de 16 a 32 KB. Todo y que de 8 a 16 KB, comienza a despuntar el aumento del área. Mientras que la progresión de 1 a 4 KB es prácticamente lineal, ya que el área del TLB con el paso de un tamaño a otro a penas sufre cambios. Analizando el área a partir del número de puertos, destaca que si bien para L=1 E=1 se produce a penas una diferencia de unos 21 ns entre el mayor y el menor tamaño de TLB, no ocurre igual para el caso extremo estudiado; L=4 E=4, el cual genera una diferencia de 132 ns. Por lo que se hace evidente el claro aumento experimentado entre ambos casos. También se puede apreciar, como a menor número de puertos más lineal será la progresión del área. Hecho que no ocurre con un número más elevado de puertos, la cual evoluciona más de forma exponencial. Comparandos los casos en el que fijado el número de puertos de lectura se modifica el número de puertos de escritura, se observa como si bien se produce una ligera diferencia en el crecimiento del área total del TLB, ésta no es muy notable. 107
PFC: Análisis TLB – Mónica Larruy Carrete 6.4.4.3.
Consumo: lectura y escritura a) b) c) d) e) a)
Figura 57: Consumo de lectura y escritura en función del número de puertos L=1 E=1 b) L=2 E=1 c) L=2 E=2 d) L=4 E=1 e) L=4 E=4 108
PFC: Análisis TLB – Mónica Larruy Carrete En general, el consumo de lectura llega a ser prácticamente el doble respecto al de escritura. Si bien el de escritura a penas se ve modificado (comportamiento lineal), el de lectura produce un claro ascenso al pasar de un tamaño de TLB de 16 a 32 KB. Mientras que el consumo previo a un tamaño de 16 KB es muy uniforme. Cabe destacar la pequeña disminución que se produce en el consumo de lectura para todas las figuras 57, al pasar de 1 a 16 KB. La mayor diferencia que se experimenta durante esta evolución, radica en poco más de 2 ns para L=4 E=1 (figura 57 d)) y para L=4 E=4 (figura 57 e)). Para el resto de casos, el valor máximo pasa a ser de 1 ns. Tal como se ha mencionado, el consumo de escritura casi no varía. Un ejemplo de ello, sería la figura 57 b), donde la diferencia que se obtiene entre el tamaño de TLB mínimo al máximo es poco más de 0.25 nJ. Aunque, la mayor diferencia se obtendría para la figura 57 d), donde se obtienen 0.77 nJ. Dicho valor es ridículo, en comparación con el máximo alcanzado para el consumo de lectura, en L=4 E=4, de 4.8 nJ. 6.4.4.4.
Evolución consumo puertos lectura Figura 58: Evolución del consumo de los puertos de lectura Para el caso de L=1 E=1, no se produce ningún gran aumento en el consumo, exceptuando el paso de 512 bytes a 1 KB. Se podría decir que es bastante lineal. Pero en general, se tiende a una evolución exponencial. En la que los valores máximos se alcanzarán para un tamaño de TLB de 32 KB. El mayor crecimiento se genera al pasar de L=2 E=2 a L=4 E=1, tal y como cabía esperar. Ya que es en el punto donde se produce la diferencia más notable en el aumento del número de puertos. 109
PFC: Análisis TLB – Mónica Larruy Carrete 6.4.5. Evolución consumo puertos escritura Figura 59: Evolución del consumo de los puertos de escritura Tal y como ya se había comentado en la evolución del consumo de puertos de lectura, la mayor diferencia generada de consumo tiene lugar al pasar de L=2 E=2 a L=4 E=1. Para todos los casos, se tiende a un comportamiento lineal, ya que apenas se producen grandes aumentos entre un tamaño de TLB y el siguiente. El crecimiento más destacado se vuelve a experimentar al pasar de 16 a 32 KB. Se puede apreciar, en la figura 59, que el paso de 1 a 2 KB, llega a generar una pequeña disminución del consumo en vez de un ligero aumento. Pero al igual que pasaba para el consumo de lectura, esta diferencia es tan pequeña que no es significativa. 6.4.5.1.
Comparativa: consumo lectura vs consumo escritura Figura 60: Comparativa consumo lectura y consumo escritura En la figura 60, se muestra la progresión global del consumo de lectura en comparación con el de escritura. En ella se puede apreciar, como el consumo de escritura alcanza valores mucho menores que los de la lectura, tendiendo a ser la mitad. 110
PFC: Análisis TLB – Mónica Larruy Carrete 7. ESTUDIO DINÁMICO CON SIMPLESCALAR 7.1. Introducción SimpleScalar cuenta con funciones creadas mediante código de programación (lenguaje “C”), formando las mismas etapas de un procesador real. Tal como se comentó en apartados anteriores, es un software gratuito que funciona mediante el sistema operativo Linux, ya que su código sólo se compila con las versiones de gcc que contiene el sistema. Una vez configurado, el simulador se ejecutará paso a paso como un procesador real y entregará datos estadísticos, los cuales son muy aproximados a una máquina real. Este simulador posee las siguientes ventajas: ‐
Expandible Æ el código fuente está incluido en la distribución y permite expandir el conjunto de instrucciones de la arquitectura. ‐
Portable Æ es posible ejecutarlo en la mayoría de las plataformas UNIX del mercado. ‐
Detallado Æ se incluyen varios simuladores. ‐
Rendimiento Æ son simuladores relativamente rápidos. Esta aplicación no es un único simulador sino que representa un kit de simuladores cada uno con una funcionalidad específica. Para este estudio nos centraremos en el sim‐outorder, que es el más complicado y detallado. La implementación del simulador está formada por varios módulos, los cuales se muestran en la figura 61. Cada uno de ellos está formado por un archivo de cabecera (*.h) y un archivo de implementación (*.c) en lenguaje C. El módulo Bpred corresponde a la implementación del predictor de saltos, existiendo varios tipos disponibles. El módulo Resource cuenta con las rutinas para el manejo de recursos como son unidades funcionales y la ventana de instrucciones. El módulo EventQ controla las colas de la arquitectura. El módulo Loader es el primero que contacta con el programa de carga que se le asigna al simulador, ya que actualiza los valores en la memoria virtual simulada. El módulo Regs cuenta con la implementación de los registros de la arquitectura. El módulo Memory dispone de las rutinas para manejar el espacio de memoria virtual simulado, junto con las operaciones del segmento de memoria. El módulo Cache contiene la implementación de la memoria caché de datos, instrucciones y TLB, junto con las rutinas de acceso a dichos elementos y rutinas de actualización. Por último, el módulo Stats se encarga de las estadísticas del simulador. 111
PFC: Análisis TLB – Mónica Larruy Carrete Figura 61: Módulos que forman el simulador sim‐outorder El procesador que se está simulando atiende a las líneas generales de una arquitectura superescalar común con dos particularidades por ser algo menos frecuentes; la codificación de las instrucciones de 64 bits y el uso de la RUU (Register Update Unit). El núcleo principal del simulador, mostrado en la figura 61, se ubica en la función sim_main(): se comienza con una fase de inicialización. Posteriormente, se pasa a un bucle infinito en el que cada iteración corresponde a un ciclo del procesador. El hecho de que el orden del pipeline sea hacia atrás es para gestionar correctamente los registros interetapa. Cuando el programa en ejecución termina con la llamada al sistema exit(), el simulador realiza una llamada a longjmp() a la función main() para generar las estadísticas. ruu_init();
Å Carga de valores iniciales
for(;;) {
Å Bucle infinito hasta que no existan más instrucciones a simular ruu_commit();
Å Retiro de instrucciones
ruu_writeback(); Å Postescritura de resultados
lsq_refresh();
Å Manejo de instrucciones de memoria ruu_issue();
Å Lanzamiento de instrucciones a ejecutar
ruu_dispatch(); Å Decodificación, renombramiento y despacho de instrucciones ruu_fetch();
Å Búsqueda de instrucciones
}
Figura 62: bucle principal del simulador sim‐outorder 7.2. Llamadas al sistema Cuando ejecutamos el simulador el programa generado por el archivo main.c hace toda la inicialización y carga el binario correspondiente en memoria. Entonces se llama a la función sim_main() que es específica de cada uno de los simuladores. A continuación, se inicia la simulación desde el punto de entrada del programa simulado. Las llamadas al sistema son gestionadas por un gestor de llamadas proxy handler que se encuentra en el archivo syscall.c que integra las llamadas al sistema realizadas por el binario 112
PFC: Análisis TLB – Mónica Larruy Carrete simulado, decodifica la llamada al sistema, copia los argumentos de dicha llamada trasladándola al SO de la máquina sobre la que se ejecuta el simulador y posteriormente copia los resultados en la memoria del simulador del programa. La memoria usa un espacio de 32 bits y está definida tal y como se muestra en la figura 63: Figura 63: Espacio de memoria de SimpleScalar basado en la arquitectura PISA 7.3. Ejecución dinámica SimpleScalar simula la ejecución de las instrucciones fuera de orden y está basado en la unidad de actualización de registros, RUU. Este esquema usa un buffer de reordenamiento para renombrar registros automáticamente y almacenar resultados con dependencia de datos. En cada ciclo el buffer de reordenamiento retira las instrucciones que han sido completadas de acuerdo a la secuencia original del programa escribiendo en el conjunto interno de registros. 7.4. Predicción de saltos En SimpleScalar se tienen diferentes tipos de predictores de saltos: not‐taken, taken, perfect, bimod, two‐level y combinado. Para los estudios realizados se ha optado por bimod. En los predictores se puede configurar el número de entradas de la tabla del predictor bimodal, en el de dos niveles se puede especificar el número de entradas en cada nivel, el tamaño del stack, se puede configurar en el BTB (branch target buffer) el número de conjuntos que se puede tener y la asociatividad. 113
PFC: Análisis TLB – Mónica Larruy Carrete 7.5. Jerarquía memoria En el simulador SimpleScalar se puede configurar la memoria caché especificando el tipo de asociatividad: directamente asociativa, completamente asociativa o asociatividad de conjuntos, y el número de conjuntos; la política de reemplazamiento: FIFO o aleatorio; el tamaño de la memoria caché y el tamaño de los bloques para el TLB. Si se tienen dos niveles de memoria, se puede configurar el tamaño de los dos niveles para la caché de datos y la caché de instrucciones y el número de entradas para el TLB de datos y el número de entradas para el TLB de instrucciones. 7.6. El Pipeline A continuación se pasará a exponer detalladamente cada una de las etapas que intervienen en el pipeline del simulador, pero previamente se muestra la organización final del mismo: Figura 64: Pipeline del procesador sim‐outorder del SimpleScalar 7.6.1. Etapa fetch Esta representa la primera etapa del pipeline, donde las instrucciones son llevadas de memoria al procesador. Al final de la etapa, las instrucciones quedan almacenadas en una cola, denominada cola de fetch (IFQ) y está implementada en la rutina ruu_fetch(). Como función recibe como entrada: ‐
Contador de programa. ‐
El predictor de estados (bpred.[h/c]). ‐
Detección de fallos en la unidad de predicción de saltos. 114
PFC: Análisis TLB – Mónica Larruy Carrete En cada ciclo se extraen instrucciones de una sola línea de la caché de instrucciones y se bloquea la extracción si ocurre algún fallo en dicha caché hasta que se resuelva. Debido a que se para el procesador, hay que tratar en la medida de lo posible fallos de caché y de TLB. 7.6.2. Etapa dispatch Aquí se modelan la decodificación, el renombre de registros, la RUU (Register Update Unit) y la LSQ (Load Store Queue). Esta etapa se encuentra implementada en la subrutina ruu_dispatch(), teniendo como entradas: ‐
Instrucciones de la IFQ. ‐
Ocupación de RUU/LSQ. ‐
La tabla de renombre. Una vez por ciclo, la emisión de instrucciones toma tantas instrucciones cómo es posible de la IFQ para colocarlas en la cola de planificación. Si ocurre un fallo en la predicción se usan buffers de estado especulativos. En ellos se almacenan las direcciones de vuelta, antes de realizar un salto especulativo, para poder recuperar el estado anterior si la predicción no es correcta. En esta etapa se meten y enlazan instrucciones en la RUU y la LSQ. Al final del dispatch se dispondrá de la RUU y la LSQ actualizadas. 7.6.3. Etapa issue Esta etapa se localiza en las subrutinas ruu_issue() y lsq_refresf(). A lo largo de la etapa se activan las instrucciones y son enviadas a las unidades funcionales considerando las dependencias existentes en memoria y en los registros. Al final, se tendrá RUU/LSQ. En cada ciclo se buscan las instrucciones que contienen los registros fuente disponibles. La emisión de las cargas de memoria que están preparadas es detenida si existen almacenamientos anteriores con la dirección efectiva no resuelta en la cola LSQ. Además, si ocurre que la dirección de un almacenamiento anterior coincide con la carga que está esperando, el valor del almacenamiento es adelantado a la carga. De todas formas, la carga es enviada al sistema de memoria. 115
PFC: Análisis TLB – Mónica Larruy Carrete 7.6.4. Etapa execute En la etapa execute se modelan las unidades funcionales y la caché de datos. La implementación de la misma está en la subrutina ruu_issue(). Como entradas se tiene: ‐
Instrucciones listas para ejecutar procedentes de la etapa issue. ‐
Estado de las unidades funciones y de la caché de datos. Se comprueba la disponibilidad de las unidades funciones, de forma que si están disponibles y cuentan con puertos de acceso libres, se emiten las instrucciones. Como salidas tiene: ‐
Caché da datos y unidades funcionales actualizadas. ‐
Eventos de postescritura. 7.6.5. Etapa writeback Corresponde a la subrutina ruu_writeback() del simulador. Como entradas tiene: ‐
Instrucciones completadas en la cola de eventos (RUU, LSQ). ‐
Estados de RUU/LSQ. En cada ciclo se comprueba la cola de eventos para ver si existen instrucciones acabadas. Cuando se encuentre una, se recorre la cadena de dependencias para marcar aquellas instrucciones que son dependientes y se marcan como listas para ser ejecutadas. También detecta fallos en la predicción. De forma que cuando ocurra uno, se regresa al punto de bifurcación descartando las instrucciones que han sido ejecutadas erróneamente, y se liberarán las operaciones de memoria que se hayan hecho de modo especulativo. 7.6.6. Etapa commit Esta etapa se implementa en la subrutina ruu_commit(). Aquí se simula la retirada en orden de las instrucciones que están almacenadas en la RUU. Se actualiza la caché y se tratan los fallos del TLB de datos. Como entradas cuenta con: ‐
Instrucciones completadas en RUU/LSQ que están preparadas para ser retiradas. ‐
Estado de la caché de datos. 116
PFC: Análisis TLB – Mónica Larruy Carrete A cada ciclo, se retirarán de la RUU las instrucciones que están preparadas. Ello se hace hasta que se encuentre una que no lo está. Entonces los resultados se llevan a los registros de la arquitectura, quedando los recursos LSQ y RUU disponibles. 7.7. Cargas de trabajo (Benchmarks SPEC2000) SPEC (Standard Performance Evaluation Corporation) establecida en 1988 como una corporación dedicada a establecer y mantener un conjunto estandarizado de benchmarks que pueden ser aplicados a computadoras de alto rendimiento. Un benchmark no es más que un estándar de medición o evaluación para comparar el nivel de rendimiento de componentes y/o sistemas completos en arquitectura de computadoras. Con el objetivo de evaluar las distintas propuestas que se hacen en este trabajo es necesario seleccionar, además de la configuración de la arquitectura del computador, el conjunto de programas de prueba (benchmark) que se utilizarán de forma que los resultados y posteriores conclusiones obtenidas sean lo más fiables posibles. El benchmark elegido ha sido SPEC200013. Este software fue diseñado para tener una medida de rendimiento de cómputo intensivo del procesador, la jerarquía de memoria y el compilador de un sistema de cómputo con propósitos de análisis de comparación. Se encuentra dividido en dos grupos, uno diseñado para medir cargas de trabajo con enteros y otro con punto flotante. Los benchmarks de tipo entero utilizados se muestran en la tabla 12. Mientras que los de punto flotante usados son los representados en la tabla 13. Nombre bzip gcc gzip mcf vortex vpr Área de aplicación
Compresión
Compilador de lenguaje C
Compresión
Combinatoria
Base de datos orientadas a objetos FPGA
Tabla 12: Benchmarks SPEC2000 de aritmética de enteros (SPECINTs) 13
Los benchmarks SPEC2000 pueden ejecutarse en los siguientes sistemas: AIX 413/RS6000, AIX 413/RS6000, HPUX/PA‐RISC, SunOS 4.1.3/SPARC, Linux 1.3/x86, Solaris 2/SPARC, Solaris 2/x86, DEC Unix 3.2/Alpha, FreeBSD 2.2/x86, Windows NT/x86, MacOS X e Intel Itanium 117
PFC: Análisis TLB – Mónica Larruy Carrete Nombre art equake mesa Área de aplicación
Reconocimiento de imágenes /Redes neuronales Simulación de propagación de ondas sísmicas Biblioteca de gráficas 3D
Tabla 13: Benchmarks SPEC2000 de punto flotante (SPECFPs) La heurística de experimentación es la siguiente: para realizar las pruebas a un nuevo modelo de arquitectura, se realizan simulaciones con una arquitectura convencional aplicándosele las cargas de trabajo representativas (benchmarks) para medir su rendimiento. Posteriormente, se adecua la herramienta de simulación para simular el nuevo diseño y se le aplican los mismos benchmarks. Los resultados de ambas simulaciones, tanto de la arquitectura convencional como la del nuevo diseño, se comparan para medir el rendimiento obtenido con el nuevo diseño, si los resultados no son alentadores, se plantea otro diseño o se realizan modificaciones al diseño propuesto. 7.8. Entorno y diseño Antes de ejecutar ninguna prueba fue necesario establecer la configuración del simulador donde estas se ejecutarían. Además fue necesario realizar una serie de modificaciones sobre el simulador con el fin de adaptarlo para poder trabajar con dos niveles de TLB. También era imprescindible fijar cuáles iban a ser las pruebas, cuáles iban a ser sus objetivos, así como las medidas que se iban a utilizar para valorar los resultados obtenidos. 7.8.1. Arquitectura de simulación Para la realización del estudio dinámico, se ha ejecutado el simulador sim‐outorder sobre una máquina superescalar con arquitectura PISA (Portable Instruction Set Architecture). Esta arquitectura se caracteriza por: 1) Contener un conjunto sencillo de instrucciones Æ MIPS/DLX + otros modos de direccionamiento. 2) Definición del conjunto de instrucciones big‐endian14 Æ facilita la portabilidad. 3) Codificación de instrucciones de 64 bits Æ facilita la investigación. 4) 16‐bits de espacio para sugerencias, nuevas instrucciones y anotaciones. 14
Si bien la arquitectura MIPS permite almacenar tanto big‐endian como little‐endian, PISA únicamente permite esta primera. Consiste en que el byte con el valor más bajo es el situado más a la izquierda. 118
PFC: Análisis TLB – Mónica Larruy Carrete 5) Uso de cuatro operandos para el formato de instrucciones, hasta 256 registros. Tal como se ha mencionado, PISA es una arquitectura basada en MIPS (Microprocessor without Interlocked Pipeline Stages). MIPS es una arquitectura de procesadores tipo RISC desarrollada por MIPS Computer Systems Inc. Un procesador RISC (Reduced Instruction Set Computer), Computadora con Conjunto de Instrucciones Reducidas. Es un tipo de microprocesador con las siguientes características fundamentales: 1.
Instrucciones de tamaños fijos y presentadas en un reducido número de formatos. 2.
Sólo las instrucciones de carga y almacenamiento acceden a la memoria por datos. 3.
Los conjuntos de instrucciones y los conjuntos de datos suelen estar conceptualmente separados. Consiguiendo así que la caché de datos y la de instrucciones sean accedidas separadamente, lo que en ocasiones puede llegar a mejorar el rendimiento. 4.
Suelen disponer de muchos registros de propósito general. El objetivo de diseñar máquinas con esta arquitectura es posibilitar la segmentación y el paralelismo en la ejecución de instrucciones y reducir los accesos a memoria. RISC es una filosofía de diseño de CPU a favor de conjuntos de instrucciones pequeñas y simples que requieren menos tiempo para ejecutarse. El tipo de procesador más utilizado en equipos de escritorio; el x86, se basa en CISC en lugar de RISC, aunque debido a la sencillez de las instrucciones RISC, las versiones más actuales traducen instrucciones CISC x86 a instrucciones más simples basadas en RISC. El motivo de la aparición de la arquitectura RISC se debió a que muchas de las características que eran incluidas en los diseños tradicionales de CPU para aumentar la velocidad estaban siendo ignoradas por los programas que eran ejecutados en ellas. Además, la velocidad del procesador en relación con la memoria a la que se accedía era cada vez más alta. Ello conllevó a la aparición de numerosas técnicas para reducir el procesamiento dentro del CPU, así como de reducir el número total de accesos a memoria. Las máquinas RISC protagonizan la tendencia actual de construcción de microprocesadores. MIPS es un ejemplo de ello. Los sistemas basados en procesadores MIPS típicamente dividen la memoria en tres partes (ver figura 63). La primera parte, segmento de texto (programa) se encuentra en la parte baja de la 119
PFC: Análisis TLB – Mónica Larruy Carrete memoria. Comienza en la dirección 400000 hex y es donde se almacenan las instrucciones del programa. Encima del segmento de texto, encontramos el segmento de datos que a su vez se divide en área estática y dinámica. El área estática comienza en la dirección 10000000 hex. Contiene objetos cuyos tamaños son conocidos por el compilador y existen mientras ejecuta el programa. El área dinámica es asignada a medida que es solicitado a través de malloc (por ejemplo, lenguaje C). La tercera parte es el segmento STACK (pila) se encuentra a partir de la dirección 7fffffff hex y crece en sentido contrario. Otra característica de esta arquitectura es que las operaciones aritméticas ocurren sólo en registros, por lo tanto MIPS debe incluir instrucciones para poder transferir datos desde/hacia registros y memoria. No existen operaciones aritméticas que operen Registro‐Memoria. Dado que se disponen de pocos registros, y los programas por lo general usan muchas variables, los compiladores tratan de mantener las variables más usadas en registros y el resto las coloca en memoria y utiliza instrucciones del tipo Load y Store para mover datos entre registros y memoria. 7.8.2. Modificaciones SimpleScalar El simulador de SimpleScalar utilizado para el estudio dinámico es el sim‐outorder. Éste está pensado para soportar un máximo de dos niveles de caché y únicamente uno de TLB. Así pues, se pensó en aportar una mejora a este simulador. Para ello, se optó por implementar un nuevo nivel de TLB. Con esta nueva modificación, tal como se verá en posteriores apartados, se pretende demostrar la mejoría que supone añadir a una arquitectura un nuevo nivel de TLB. Una primera opción, pasaba por modificar el fichero que interactúa directamente con la caché/TLB (cache.[c/h]). Esta modificación implicaba variar principalmente las siguientes funciones: cache_create()Æ consiste en la creación e inicialización de una caché general. Destacan las siguientes acciones: se comprueban los parámetros de la caché, se reserva memoria en función del número de conjuntos definidos, asociación del controlador de fallo/reemplazo con la correspondiente caché y asignación del algoritmo de reemplazo que se ha definido. Habría sido necesaria definir una función tlb_create(), cuya funcionalidad a grandes rasgos sería muy similar a la descrita. 120
PFC: Análisis TLB – Mónica Larruy Carrete cache_access()Æ devuelve la latencia de acceso en ciclos. En caso de acceder pueden ocurrir principalmente dos casos: ‐
Acierto (hit) Æ copia fuera los datos de bloque de caché, actualiza status a dirty si se está escribiendo y se guarda el último bloque acertado. ‐
Fallo (miss) Æ se selecciona (por LRU) el bloque a reemplazar. No se reemplazará hasta que el bus del siguiente nivel esté disponible. Se hubiese tenido que definir la función tlb_access()con unas características prácticamente idénticas a las descritas para cache_access(). Pero finalmente, por motivos de simplicidad, en lugar de la modificación del fichero cache.[c/h]se decidió mantener este fichero y realizar la implantación del segundo nivel del TLB directamente sobre el fichero sim-outorder.c. Así pues, a continuación se pasan a describir todas las variaciones realizadas sobre dicho fichero. 1) Definición de los dos niveles de la jerarquía TLB. Hasta ahora únicamente había una única estructura de D‐TLB y otra para I‐TLB. Por lo que ha sido necesaria la definición de cuatro estructuras; D‐TLB e I‐TLB para L1 y para L2: /* level 1 instruction TLB, entry level instruction TLB */
static struct cache_t *tlb_il1;
/* level 2 instruction TLB */
static struct cache_t *tlb_il2;
/* level 1 data TLB, entry level data TLB */
static struct cache_t *tlb_dl1;
/* level 2 data TLB */
static struct cache_t *tlb_dl2;
En la estructura cache_t, utilizada tanto para definir cachés como TLBs, destacan los siguientes campos: nombre de la caché, número de conjuntos, tamaño del bloque en bytes, tamaño de los datos asignados al usuario (útil para TLB, ya que guarda información como la dirección de la página física), grado de asociativitat, política de reemplazo, latencia de acierto (para caché) o de fallo (para TLB), handler de fallo/reemplazo, contadores (número de aciertos de fallos, de reemplazos, de escrituras a través y de invalidaciones) y último bloque de acierto usado para optimizar el procesamiento de acierto de la caché. 121
PFC: Análisis TLB – Mónica Larruy Carrete NOTA: A la hora de realizar un fichero de configuración se debe tener en cuenta: En vez de definir tlb:dtlb habrá que especificar tlb:dtlbl1 y tlb:dtlbl2. En lugar de tlb:itlb se deberá definir tlb:itlbl1 y tlb:itlbl2. 2) Se han añadido las opciones para D‐TLB e I‐TLB de L1 y L2: /* l1 data TLB config, i.e., {<config>|none} */
static char *tlb_dl1_opt;
/* l1 instruction TLB config, i.e., {<config>|dtlbl1|dtlbl2|none} */
static char *tlb_il1_opt;
/* l2 data TLB config, i.e., {<config>|none} */
static char *tlb_dl2_opt;
/* l2 instruction TLB config, i.e., {<config>|dtlbl2|none} */
static char *tlb_il2_opt;
Si se desea definir un TLB, obligatoriamente se deberá definir primeramente L1, y posteriormente se permite que L2 pueda ser o no unificado con L1. 3) Adaptada tlb_miss_lat para latencia TLB (D‐TLB e I‐TLB) L1, ahora pasa a llamarse
tlb_miss_lat_L1 y añadida tlb_miss_lat_L2 para latencia TLB (D‐TLB e I‐TLB) L2. /* inst/data TLB miss latency L1 (in cycles) */
static int tlb_miss_lat_L1;
/* inst/data TLB miss latency L2 (in cycles) */
static int tlb_miss_lat_L2;
NOTA: De cara a la realización de un fichero de configuración se debe considerar que ahora en vez de introducir tlb:lat habrá que añadir tlb:latMissL1 y tlb:latMissL2. Ambas hacen referencia a la latencia de fallo, para la latencia de acierto se considera por defecto 1 para ambos casos. 4) Comprobación de parámetros de latencia para L1 y L2 deben ser más grandes que cero. if (tlb_miss_lat_L1 < 1)
fatal("L1 TLB miss latency must be greater than zero");
if (tlb_miss_lat_L2 < 1)
fatal("L2 TLB miss latency must be greater than zero");
122
PFC: Análisis TLB – Mónica Larruy Carrete 5) Adaptación de los handlers de fallo/reemplazo para soportar dos niveles de TLB. Cuando se detecta un fallo o reemplazo se invoca al manipulador (handler) de fallo o reemplazo asociado para recuperarse de esta situación. Previamente a la modificación, únicamente existía un handler para D‐TLB y otro para I‐
TLB, ambos con la misma funcionalidad: 1º) Almacenar la dirección del bloque en la dirección de la página física. 2º) Comprobar la condición 'test' a partir de la dirección almacenada previamente y según el resultado puede llegar a abortar el programa. 3º) Devolver la latencia de fallo fijada del TLB. Ante la incorporación de un segundo nivel de TLB se han tenido que definir cuatro handlers, los cuáles paso a exponer a continuación: •
D‐TLB L1 En caso de producirse un fallo/reemplazo en D‐TLB L1 se invocará a esta función, la cual se encargará de comprobar que se dispone de D‐TLB L2, en caso de ser así se accederá a este nuevo nivel para obtener la dirección que no se ha encontrado anteriormente en L1. Por ello, en caso de tratarse de una lectura se devolverá la latencia de acceso a D‐TLB L2, sino se retornará la latencia de fallo definida por el usuario para D‐TLB L1. Con este nuevo acceso a D‐TLB L2 se conseguirá reducir la penalización que supondría para D‐TLB L1 tener que acceder a caché para obtener la dirección deseada. /* l1 data TLB block miss handler function */
static unsigned int
/* latency of block access */
tlb_dl1_access_fn(enum mem_cmd cmd,
/* access cmd, Read or Write */
md_addr_t baddr,
/* block address to access */
/* @ = word-32 bits */
int bsize,
/* size of block to access */
struct cache_blk_t *blk, /* ptr to block in upper level */
tick_t now)
/* time of access */
{
unsigned int lat;
/*It saves the address of the block in the physical address of the
page */
md_addr_t *phy_page_ptr = (md_addr_t *)blk->user_data;
/*
no
real
memory
access,
however,
should
have
user
data
space
attached */
123
PFC: Análisis TLB – Mónica Larruy Carrete /*
Check
the
condition
'test'
and
as
the
result
might
abort
the
program */
assert(phy_page_ptr);
/* If exists L2 D-TLB => return latency access */
if (tlb_dl2)
{
/* access next level of data TLB hierarchy */
lat = cache_access(tlb_dl2, cmd, baddr, NULL, bsize,
/* now */now, /* pudata */NULL, /* repl addr */NULL);
if (cmd == Read)
return lat;
else
/* FIXME: unlimited write buffers */
return tlb_miss_lat_L1;
}
else return tlb_miss_lat_L1;
}
•
D‐TLB L2 En el momento en que se genere un fallo/reemplazo en D‐TLB L2 se llamará al handler mostrado a continuación. Éste únicamente devolverá la latencia de fallo del TLB L2 en caso de tratarse de una operación de lectura, en su defecto se retornará cero. static unsigned int
/* latency of block access */
tlb_dl2_access_fn(enum mem_cmd cmd,
/* access cmd, Read or Write */
md_addr_t baddr,
/* block address to access */
int bsize,
/* size of block to access */
struct cache_blk_t *blk,
/* ptr to block in upper level */
tick_t now)
/* time of access */
{
if (cmd == Read)
return tlb_miss_lat_L2;
else
/* FIXME: unlimited write buffers */
return 0;
}
124
PFC: Análisis TLB – Mónica Larruy Carrete •
I‐TLB L1 Si se llega a generar un fallo/reemplazo en I‐TLB L1 se invocará a esta rutina, la cual sigue una estrategia muy similar a la del handler para D‐TLB L1. La diferencia únicamente radica en que a la hora de que se trate de un acceso de escritura, si bien para D‐TLB L1 se devolvía una latencia igual a cero, ahora no se soporta. /* l1 instruction TLB block miss handler function */
static unsigned int
/* latency of block access */
tlb_il1_access_fn(enum mem_cmd cmd,
/* access cmd, Read or Write */
md_addr_t baddr,
/* block address to access */
int bsize,
/* size of block to access */
struct cache_blk_t *blk,
/* ptr to block in upper level */
tick_t now)
/* time of access */
{
unsigned int lat;
/*It saves the address of the block in the physical address of the
page */
md_addr_t *phy_page_ptr = (md_addr_t *)blk->user_data;
/*
no
real
memory
access,
however,
should
have
user
data
space
attached */
assert(phy_page_ptr);
/* If exists L2 D-TLB => return latency access */
if (tlb_il2)
{
/* access next level of instruction TLB hierarchy */
lat = cache_access(tlb_il2, cmd, baddr, NULL, bsize,
/* now */now, /* pudata */NULL, /* repl addr */NULL);
if (cmd == Read)
return lat;
else{
return tlb_miss_lat_L1;
panic("writes to instruction not supported");
}
}
else return tlb_miss_lat_L1;
}
125
PFC: Análisis TLB – Mónica Larruy Carrete •
I‐TLB L2 Al igual que en el anterior handler, el de I‐TLB L2 es muy similar al de D‐TLB L2. De nuevo la direncia radica en que en el caso de la operación de escritura no se devolverá latencia, sino que se informará de que no se soporta. /* l2 instruction TLB block miss handler function */
static unsigned int
/* latency of block access */
tlb_il2_access_fn(enum mem_cmd cmd,
/* access cmd, Read or Write */
md_addr_t baddr,
/* block address to access */
int bsize,
/* size of block to access */
struct cache_blk_t *blk,
/* ptr to block in upper level */
tick_t now)
/* time of access */
{
/* this is a miss to the lowest level */
if (cmd == Read)
return tlb_miss_lat_L2;
else
panic("writes to instruction not supported");
}
6) void sim_reg_options(struct opt_odb_t *odb); Esta función se encarga de registrar las opciones específicas del simulador. La modificación introducida consiste en que se ha añadido la posibilidad de poder capturar las opciones para ITLB y DTLB de segundo nivel. También se realiza la captura de la definición de la latencia de fallo para el TLB L2. Y por último, se permite la opción de especificar un TLB de segundo nivel unificado. 7) void sim_check_options(struct opt_odb_t *odb, int argc, char **argv); Comprueba que los valores específicos del simulador se definen correctamente. Así pues, ante la introducción de un nuevo nivel de TLB será necesario verificar su adecuada definición. Anteriormente se tenía: ƒ
Comprobación para I‐TLB: /* use an I-TLB? */
if (!mystricmp(itlb_opt, "none"))
itlb = NULL;
else
{
if (sscanf(itlb_opt, "%[^:]:%d:%d:%d:%c",
126
PFC: Análisis TLB – Mónica Larruy Carrete name, &nsets, &bsize, &assoc, &c) != 5)
fatal("bad
TLB
parms:
<name>:<nsets>:<page_size>:<assoc>:<repl>");
itlb = cache_create(name, nsets, bsize, /* balloc */FALSE,
/*
usize
*/sizeof(md_addr_t),
assoc,
cache_char2policy(c), itlb_access_fn,
/* hit latency */1);
}
ƒ
Verificación para D‐TLB: /* use a D-TLB? */
if (!mystricmp(dtlb_opt, "none"))
dtlb = NULL;
else
{
if (sscanf(dtlb_opt, "%[^:]:%d:%d:%d:%c",
name, &nsets, &bsize, &assoc, &c) != 5)
fatal("bad
TLB
parms:
<name>:<nsets>:<page_size>:<assoc>:<repl>");
dtlb = cache_create(name, nsets, bsize, /* balloc */FALSE,
/* usize */sizeof(md_addr_t), assoc,
cache_char2policy(c), dtlb_access_fn,
/* hit latency */1);
} Con las nuevas variaciones es necesario realizar las siguientes verificaciones: •
D‐TLB: /* use a level 1 D-TLB? */
/* D-TLB L1 is not defined and attempts to define L2 D-TLB => ERROR */
if (!mystricmp(tlb_dl1_opt, "none"))
{
tlb_dl1 = NULL;
/* the level 2 D-TLB cannot be defined */
if (strcmp(tlb_dl2_opt, "none"))
fatal("the l1 data TLB must defined if the l2 TLB is
defined");
tlb_dl2 = NULL;
}
/* D-TLB L1 is defined */
else
127
PFC: Análisis TLB – Mónica Larruy Carrete {
/* Wrong parameters => Error */
/* Correct parameters => creation D-TLB L1 */
if (sscanf(tlb_dl1_opt, "%[^:]:%d:%d:%d:%c",
name, &nsets, &bsize, &assoc, &c) != 5)
fatal("bad
l1
D-TLB
parms:
<name>:<nsets>:<bsize>:<assoc>:<repl>");
tlb_dl1 = cache_create(name, nsets, bsize, /* balloc */FALSE,/*
usize
*/sizeof(md_addr_t),
assoc,
cache_char2policy(c),
tlb_dl1_access_fn,/* hit latency */0);
/* is the level 2 D-TLB defined? */
if (!mystricmp(tlb_dl2_opt, "none"))
/* D-TLB L2 undefined =>
It does not take configuration
parameters*/
tlb_dl2 = NULL;
else
{
/* D-TLB L2 define => check parameters:
If OK => create TLB
Else => ERROR */
if (sscanf(tlb_dl2_opt, "%[^:]:%d:%d:%d:%c",
name, &nsets, &bsize, &assoc, &c) != 5)
fatal("bad l2 D-TLB parms:
<name>:<nsets>:<bsize>:<assoc>:<repl>");
tlb_dl2 = cache_create(name, nsets, bsize, /* balloc
*/FALSE, /* usize
*/sizeof(md_addr_t),assoc,cache_char2policy(c),tlb_dl2_acc
ess_fn, /* hit latency */2);
}
}
•
I‐TLB: /* use a level 1 I-TLB? */
/* I-TLB L1 undefined and try to define I-TLB L2 => ERROR */
if (!mystricmp(tlb_il1_opt, "none"))
{
tlb_il1 = NULL;
/* the level 2 I-TLB cannot be defined */
if (strcmp(tlb_il2_opt, "none"))
fatal("the l1 inst TLB must defined if the l2 TLB is
defined");
128
PFC: Análisis TLB – Mónica Larruy Carrete tlb_il2 = NULL;
}
/* Attempted access to L1 D-TLB not defined L1 I-TLB => L1 I-TLB = L1
D-TLB */
else if (!mystricmp(tlb_il1_opt, "dtlbl1"))
{
if (!tlb_dl1)
fatal("I-TLB l1 cannot access D-cache l1 as it's
undefined");
tlb_il1 = tlb_dl1;
/* the level 2 I-cache cannot be defined */
/* Attempted access to L2 I-TLB not defined L1-ITLB => ERROR*/
if (strcmp(tlb_il2_opt, "none"))
fatal("the l1 I-TLB must defined if the l2 I-TLB is
defined");
tlb_il2 = NULL;
}
/* Attempted access to L2 D-TLB not defined L1 I-TLB => L1 I-TLB = L2
D-TLB */
else if (!mystricmp(tlb_il1_opt, "dtlbl2"))
{
if (!tlb_dl2)
fatal("I-TLB l1 cannot access D-TLB l2 as it's
undefined");
tlb_il1 = tlb_dl2;
/* the level 2 I-TLB cannot be defined */
/* Attempted access to L2 I-TLB not defined L1 I-TLB => ERROR*/
if (strcmp(tlb_il2_opt, "none"))
fatal("the l1 inst TLB must defined if the l2 TLB is
defined");
tlb_il2 = NULL;
}
/* L1 ITLB is defined */
else
{
/* Check parameters: If OK => create TLB
Else => ERROR */
if
(sscanf(tlb_il1_opt,
"%[^:]:%d:%d:%d:%c",name,
&nsets,
&bsize,
&assoc, &c) != 5)
129
PFC: Análisis TLB – Mónica Larruy Carrete fatal("bad
l1
I-TLB
parms:
<name>:<nsets>:<bsize>:<assoc>:<repl>");
tlb_il1 = cache_create(name, nsets, bsize, /* balloc */FALSE,
/* usize */sizeof(md_addr_t), assoc, cache_char2policy(c),
tlb_il1_access_fn, /* hit lat */0);
/* is the level 2 D-TLB defined? */
/* L2 I-TLB undefined => L2 I-TLB = null*/
if (!mystricmp(tlb_il2_opt, "none"))
tlb_il2 = NULL;
/* L2 I-TLB defined and attempted to access L2 I-TLB undefined=> to
access D-TLB Æ I-TLB should be defined */
else if (!mystricmp(tlb_il2_opt, "dtlbl2
{
if (!tlb_dl2)
fatal("I-TLB l2 cannot access D-TLB l2 as it's undefined");
tlb_il2 = tlb_dl2;
}
/* L2 I-TLB defined, check parameters: If OK => create TLB
Else => ERROR */
else
{
if (sscanf(tlb_il2_opt, "%[^:]:%d:%d:%d:%c",
name, &nsets, &bsize, &assoc, &c) != 5)
fatal("bad l2 I-TLB parms: "
"<name>:<nsets>:<bsize>:<assoc>:<repl>");
tlb_il2 = cache_create(name, nsets, bsize, /* balloc */FALSE,
/* usize */sizeof(md_addr_t), assoc, cache_char2policy(c),
tlb_il2_access_fn, /* hit lat */2);
}
}
NOTA: Para definir D‐TLB L2 debe estar definida D‐TLB L1. I‐TLB L1 debe existir D‐TLB L1. Para acceder a D‐TLB => I‐TLB debe existir. 8) ruu_fetch()
La modificación número 8 y 9 representan las etapas del pipeline que intervienen directamente con el TLB. En el caso de ruu_fetch, interactúa con I‐TLB. 130
PFC: Análisis TLB – Mónica Larruy Carrete Si se cuenta con el primer nivel (L1) de TLB, ahora pasará a accederse a éste, en vez de acceder anteriormente al genérico I‐TLB. if (tlb_il1)
{
/* Access L1 I-TLB */
tlb_lat = cache_access(tlb_il1, Read, IACOMPRESS(fetch_regs_PC),
NULL, ISCOMPRESS(sizeof(md_inst_t)), sim_cycle,
NULL, NULL);
if (tlb_lat > 1)
last_inst_tmissed = TRUE;
/* I-cache/I-TLB accesses occur in parallel */
lat = MAX(tlb_lat, lat);
}
9) ruu_issue() y ruu_commit()
La etapa issue interacciona con D‐TLB, mientras que la de commit trata fallos del D‐TLB. Se ha modificado para que ahora se acceda al nivel L1 de D‐TLB. •
ruu_issue():
/* All loads and stores must to access L1 D-TLB */
if (tlb_dl1 && MD_VALID_ADDR(rs->addr))
{
/* Access the L1 D-DLB */
tlb_lat = cache_access(tlb_dl1, Read, (rs->addr & ~3),
NULL, 4, sim_cycle, NULL, NULL);
if (tlb_lat > 1)
events |= PEV_TLBMISS;
/* D-cache/D-TLB accesses occur in parallel */
load_lat = MAX(tlb_lat, load_lat);
} •
ruu_commit():
/* All loads and stores must to access L1 D-TLB */
if (tlb_dl1)
{
/* access the D-TLB */
lat = cache_access(tlb_dl1, Read, (LSQ[LSQ_head].addr & ~3),
NULL, 4, sim_cycle, NULL, NULL);
if (lat > 1)
events |= PEV_TLBMISS;
}
131
PFC: Análisis TLB – Mónica Larruy Carrete 7.8.3. Configuración simulador La versión 3.0 utilizada del SimpleScalar soporta dos ISA (conjunto de instrucciones). La Alpha ISA de la antigua DEC y la PISA ISA (Portable ISA). Para la realización de este proyecto se simulará la ejecución de un procesador PISA. Esta simulación se realizará bajo entorno Linux. Parámetro fetch:ifqsize fetch:mplat bpred bpred:bimod bpred:2lev decode:width Descripción Tamaño del buffer de búsqueda de instrucciones
Latencia (ciclos) de un error de predicción de salto
Especifica el tipo de predictor de saltos
Tamaño del predictor bimodal
Configuración predictor segundo nivel
Ancho de banda del decodificador de instrucciones (instrucciones/ciclo) issue:width Ancho de banda de instrucciones lanzadas a ejecutar (instrucciones/ciclo) issue:inorder Ejecución de instrucciones en orden
issue:wrongpath Ejecución de instrucciones permitidas que se lanzan después de un error de predicción o especulativo ruu:size Tamaño de la ventana de instrucciones (ROB y RS)
lsq:size Capacidad de la cola de instrucciones de memoria (LSQ)
cache:dl1 Configuración de la caché de datos de primer nivel
(<nombre>:<#líneas>:<tamañoBloque>:<gradoAsociatividad>:
<algoritmoReemplazo>) cache:dl1lat Latencia de acierto de caché de datos de primer nivel
cache:dl2 Configuración de la caché de datos de segundo nivel
cache:dl2lat Latencia de acierto de caché de datos de segundo nivel
cache:il1 Configuración de la caché de instrucciones de primer nivel cache:il1lat Latencia de acierto de caché de datos de primer nivel
cache:il2 Configuración de la caché de instrucciones de segundo nivel cache:il2lat Latencia de acierto de caché de datos de segundo nivel
cache:flush Actualiza todas las cachés con llamadas al sistema
cache:icompress Mapea dirección de 64 bits con su equivalente de 32
mem:lat Especifica latencia de acceso a memoria
mem:width Ancho del bus de memoria (en bytes)
tlb:itlb Configuración del TLB de instrucciones
tlb:dtlb Configuración del TLB de datos
res:ialu Número de ALUs para enteros
res:imult Número de unidades para multiplicar/dividir enteros
res:memport Número de puertos de la caché de primer nivel
res:fpalu Número de ALUs para punto flotante
res:fpmult Número de unidades para multiplicar/dividir punto flotante Valor 4 3 bimod 2048 1 1024 8 4 4 false true 64 32 dl1:256:32:2:l
1 ul2:1024:64:4:l
6 il1:512:32:1:l
1 unificada
6 false false 250 2 8 Modificable
Modificable
4 1 2 4 1 Tabla 14: Valores comunes empleados para la simulación del TLB con y sin L2
132
PFC: Análisis TLB – Mónica Larruy Carrete Centrándonos más en la parte que nos interesa, la memoria ha estado configurada tal como se detalla a continuación: ‐
Caché (<nombre>:<#líneas>:<asociatividad>:<algoritmo de reemplazo>): ƒ L1 DatosÆ dl1:256:32:2:l InstruccionesÆ il1:1024:64:4:l
ƒ L2 Datos: dl2:512:32:1:l
Instrucciones: estará unificada con la caché de segundo nivel de datos. En todas ellas el algoritmo de reemplazo de páginas es el LRU (Least Recently Used). Con él se eliminarán las páginas menos usadas recientemente, ya que estadísticamente son las que tienen menor probabilidad de ser usadas nuevamente. Cabe destacar que en el segundo nivel, la caché estará unificada. Con ello la caché se utilizará indistintamente para datos como para instrucciones, al contrario que en el primer nivel que se encuentran separadas. ‐
TLB (<nombre>:<#líneas>:<tamañoPágina>:<asociatividad>:<algoritmo de
reemplzo>):
· tlb:dtlbl1 dtlbl1:#LíneasVble:4096:1:l
· tlb:dtlbl2 dtlbl2:#LíneasVble:4096:1:l
· tlb:itlbl1 itlbl1:#LíneasVble:4096:1:l
· tlb:itlbl2 dtlbl2 Para todos los casos, el algoritmo de reemplazo utilizado es el LRU, se mantiene fijo el tamaño de página a 4096 bytes y la asociatividad a 1, y en función del tamaño de TLB que se desee estudiar habrá que ir adaptando los valores asociados al número de líneas. Inicialmente, se consideró oportuno realizar los estudios con tamaños de TLB de 1 a 32 KB y ejecutando un conjunto total de instrucciones de 250 millones. Pero tras la ejecución de varios SPECs, se concluyó que el número de instrucciones no eran suficientes, ya que con éstas se obtenían una tasa de acierto en prácticamente todos los SPECs del 100%. Así pues, se pasó a probar con el aumento del número de instrucciones, probando tanto 2500 como 25000 millones de instrucciones, pero seguía sin apartarse demasiado del 100% de aciertos. Es por ello, que el correspondiente aumento del número de instrucciones trajo como consecuencia la disminución del tamaño del TLB de L1, pasando ahora a tratar con tamaños de 128, 256, 512 bytes junto con 1 y 2 KB. 133
PFC: Análisis TLB – Mónica Larruy Carrete No se ha considerado conveniente para el posterior estudio realizar pruebas con TLBs superiores a 2 KB porque se conseguía en prácticamente todos los SPECs un acierto del 100%, y para el análisis del efecto del TLB no se podrían apreciar diferencias. En resumen, se han considerado los siguientes valores para las diferentes ejecuciones realizadas: ‐
Número de instrucciones ejecutadas Æ 2500 millones. ‐
Saltos de instrucciones Æ cada 250 millones. ‐
Tamaño total TLBs (DTLB+ITLB) estudiados únicamente con L1 Æ 128, 256, 512, 1024 y 2048 bytes. ‐
Tamaño total TLBs (L1 DTLB+L1 ITLB+L2 UTLB(TLB unificado)) estudiados con L1 y L2 Æ 384, 768, 1280, 3072 y 6144 bytes. ‐
Resultados estudiados Æ miss_rate (tasa de fallos), IPC (Instrucciones ejecutadas Por Ciclo) y tiempo de acceso medio al TLB. ‐
Grados de asociatividades analizadas Æ directa. ‐
Número de líneas examinadas Æ vendrá determinado por el tamaño de TLB y el grado de asociatividad que se deseen alcanzar. A continuación, se indica en detalle para cada TLB la variación que experimentan los diferentes parámetros: Tamaño TLB Número de líneas Tamaño página Asociatividad 64 bytes 16 4096 1 128 bytes 32 4096 1 256 bytes 64 4096 1 512 bytes 128 4096 1 1 KB 256 4096 1 2 KB 512 4096 1 4 KB 1024 4096 1 Tabla 15: Valor de los parámetros número de líneas, tamaño de página y asociatividad en función del tamaño del TLB ‐
Latencias Æ Cabe destacar, que a diferencia del resto de cachés, en el TLB no se configura la latencia de hit (acierto) porque el acceso al TLB se realiza en paralelo con el de caché. ƒ
Memoria: la latencia debe ser alta, ya que es muy costoso acceder a ella. Por lo que toma el valor de 250. ƒ
Caché (instrucciones/datos): Latencia L1=1 Latencia de acierto caché unificada L2=6 134
PFC: Análisis TLB – Mónica Larruy Carrete ƒ
ƒ
‐
TLB L1: Latencia de hit=0. Latencia de miss=latencia de hit en el segundo nivel=2. TLB L2: Latencia de hit=2. Latencia de miss=latencia de acceso a memoria=250. Tamaño TLB L2 Æ para el estudio de la implementación del TLB L2 se han seleccionado los siguientes valores: Tipo y nivel TLB tlb:dtlbl1 tlb:dtlbl2 tlb:itlbl1 tlb:itlbl2 Tamaño Total TLB: 384 bytes
Configuración
Tamaño TLB (bytes) dtlbl1:16:4096:1:l
64
dtlbl2:64:4096:1:l
256
itlbl1:16:4096:1:l
64
dtlbl2
TLB unificada con dtlbl2 Tabla 16: Configuración TLB (L1 y L2) de 384 bytes Tipo y nivel TLB tlb:dtlbl1 tlb:dtlbl2 tlb:itlbl1 tlb:itlbl2 Tamaño Total TLB: 768 bytes
Configuración
Tamaño TLB (bytes) dtlbl1:32:4096:1:l
128
dtlbl2:128:4096:1:l
512
itlbl1:32:4096:1:l
128
Dtlbl2
TLB unificada con dtlbl2 Tabla 17: Configuración TLB (L1 y L2) de 768 bytes Tipo y nivel TLB tlb:dtlbl1 tlb:dtlbl2 tlb:itlbl1 tlb:itlbl2 Tamaño Total TLB: 1536 bytes
Configuración
Tamaño TLB (bytes) dtlbl1:64:4096:1:l
256
dtlbl2:256:4096:1:l
1024
itlbl1:64:4096:1:l
256
dtlbl2
TLB unificada con dtlbl2 Tabla 18: Configuración TLB (L1 y L2) de 1536 bytes Tipo y nivel TLB tlb:dtlbl1 tlb:dtlbl2 tlb:itlbl1 tlb:itlbl2 Tamaño Total TLB: 3072 bytes
Configuración
Tamaño TLB (bytes) dtlbl1:128:4096:1:l
512
dtlbl2:512:4096:1:l
2048
itlbl1:128:4096:1:l
512
dtlbl2
TLB unificada con dtlbl2 Tabla 19: Configuración TLB (L1 y L2) de 3072 bytes 135
PFC: Análisis TLB – Mónica Larruy Carrete Tipo y nivel TLB tlb:dtlbl1
tlb:dtlbl2
tlb:itlbl1
tlb:itlbl2
Tamaño Total TLB: 6144 bytes
Configuración
Tamaño TLB (bytes) dtlbl1:512:4096:1:l
32
dtlbl2:1024:4096:1:l
128
itlbl1:512:4096:1:l
32
dtlbl2 TLB unificada con dtlbl2 Tabla 20: Configuración TLB (L1 y L2) de 6144 bytes En un inicio, se realizaron pruebas con valores en los que la diferencia entre L1 y L2 era del doble, pero se observó que algunos resultados no eran muy decisivos, así pues se decidió incrementar el tamaño de L2 al doble del probado inicialmente, pasando así a trabajar con los mostrados anteriormente (tablas 16‐20). Para el desarrollo del estudio dinámico, se comparará la implementación con únicamente un nivel de TLB con uno que disponga de dos. Para este último caso, al trabajar con un TLB de segundo nivel, se ha optado por uno unificado, para conseguir así tamaños en potencia de dos y poder variar el tamaño de L2 según convenga en función del de L1. Cabe mencionar, que el hecho de que se haya fijado el grado de asociatividad a uno se debe que el objetivo del estudio es demostrar la mejoría de una implementación con un segundo nivel de TLB frente a una que no disponga de este nivel, por lo que no se ha considerado de interés realizarlo para varias asociatividades, ya que las evidencias quedarán claramente reflejadas con un único grado de asociatividad. 7.9. Análisis estudio dinámico con SimpleScalar mediante SPECs Para mejorar el rendimiento del TLB, se puede especular entre cuál es la capacidad óptima y cuál es el grado de asociatividad que mejor rendimiento presenta, entre otras características. Para medir estos parámetros se suelen usar como figura de mérito: la tasa de fallos y el tiempo medio de acceso. Un fallo se presenta cuando la información que se busca no se encuentra en el TLB y es necesaria cargarla desde la tabla de páginas o bien recurrir a MP para traer la nueva entrada. La tasa de fallos es una relación que involucra al número de veces que se busca un dato en el TLB y no se encuentra, dividido por el número total de referencias hechas al TLB. Cuando se proponen nuevos esquemas de memoria caché o TLB, su evaluación generalmente parte de un modelo de procesador convencional y consiste en buscar la mejor configuración del esquema, de forma que se minimice el tiempo de ejecución de ciertos programas de prueba. 136
PFC: Análisis TLB – Mónica Larruy Carrete Gráficas De cara al desarrollo del estudio dinámico se ha optado por realizar las siguientes gráficas: ‐
Comparativa IPC (Instrucciones Por Ciclo) entre la implementación con y sin TLB de segundo nivel. ‐
Miss_rate (tasa de fallos). Aquí se mostrará la tasa de fallos de cada una de las configuraciones y finalmente se contrastarán ambas, para conseguir así una clara evolución de cada uno de los TLBs (datos e instrucciones) implicados en las diferentes jerarquías (primer y segundo nivel). ‐
Tiempo medio de acceso al TLB. Para la realización de esta gráfica se han empleado las siguientes fórmulas: T. acceso TLB
L2
_
_ 1
_
_
T. acceso TLB _
L2
_ 1
_
_
_ 1
_ 1
_ 1
_
_
_ 1
_
_
_ 1
_ 1
_
_
_ 1
_ 1
_
_ 2
_
En cada una de las fórmulas los misses, ya sean del TLB de datos (DTLB) o del de instrucciones (ITLB), hacen referencia al número total de fallos que se produce a la hora de acceder a él y no encontrar la dirección deseada. Por su parte, el parámetro lat_mem corresponde a la latencia de acceso a memoria principal. Dicho parámetro se encuentra fijado a 250 ciclos. Por otro lado, el parámetro lat_TLB_L1 está asociado con la latencia de fallo instrucciones/datos del TLB y luego acceder a memoria, al igual que el anterior también está preestablecido, pero en este caso será igual a 2 ciclos. Otra gráfica que se había pensado realizar era la de comparar el número de accesos entre las dos posibles configuraciones de TLB. Vendría determinada por: ‐
#Accesos TLB
L2
#Accesos_DTLB_L1
#Accesos_ITLB_L1 ‐
#Accesos TLB
L2
#Accesos_DTLB_L1
#Accesos_ITLB_L1
#Accesos_TLB_L2 unificada Tal como se puede apreciar en las fórmulas adjuntas, la diferencia entre ambas únicamente radica en el número de accesos al TLB de segundo nivel, ya que por cada acceso a memoria es necesario realizar la traducción de la dirección lógica a física. Ante el hecho de que se considera una gráfica que no aporta excesiva información, debido a que sólo destacarían los accesos adicionales al TLB de segundo nivel, se optó finalmente por no incluirla. 137
PFC: Análisis TLB – Mónica Larruy Carrete 7.9.1. bzip 7.9.1.1.
IPC Tamaño
total TLB (bytes) IPC sin L2 128
256
512
1024
2048
0.2299
0.3781
0.554
0.8017
1.0238
Tamaño IPC total TLB con L2 (bytes) 384 768 1536 3072 6144 0.5301
0.7829
1.0148
1.1406
1.1725
Figura 65: Comparativa IPC SPECINT bzip con y sin TLB L2 Tabla 21: Valores de bzip IPC en función del TLB En ambas implementaciones la mejoría que se experimenta desde el TLB de menor tamaño al de tamaño máximo estudiado es de entorno 0.8 instrucciones. Si bien con tamaños pequeños no se consigue un gran número de instrucciones por ciclo, ello se solventa a medida que vaya creciendo el tamaño del TLB. La diferencia entre una y otra especificación varía en que con TLBs con L2 se consigue lograr mayor IPC que con idénticos tamaños de TLB en L1. Muestra de ello se puede apreciar tomando cualquiera de los valores de TLB estudiados con L2 y comparándolo con el tamaño contiguo para TLBs sin L2. Por ejemplo, basta con observar el TLB con 1536 bytes (L2=1KB, L1=512 => DTLB L1=256 e ITLB L1=256) y el de 512 bytes sin L2. Si bien el tamaño para L1 es el mismo, la mejora que se consigue es del doble. 7.9.1.2.
Miss_rate Figura 66: Miss_rate SPECINT bzip para TLB sólo con L1 Figura 67: Miss_rate SPECINT bzip para TLB con L1 y L2 138
PFC: Análisis TLB – Mónica Larruy Carrete Tamaño total TLB (bytes) DTLB L1 ITLB L1 128 256 512 1024 2048 0.0628 0.0368 0.0228 0.0121 0.0059 0 0 0 0 0 Tamaño TLB L2
total TLB (bytes) 384
768
1536
3072
6144
DTLB L1 ITLB L1
0.0619 0.0362 0.0225 0.0119 0.0059 0 0 0 0 0 0.3682
0.3333
0.2625
0.2311
0.317
Tabla 22: Valores miss_rate bzip para TLB sólo con L1 Tabla 23: Valores miss_rate bzip para TLB con L1 y L2 Figura 68: Comparativa miss_rate SPECINT bzip con y sin TLB L2 A partir de las gráficas anteriores es evidente que para cualquiera de los TLBs de instrucciones de L1 la tasa de fallos es cero. No ocurre igual para el de datos de primer nivel, ya que todo y disponer de una tasa de fallos mínima, no logra alcanzar valores nulos para los tamaños de TLB estudiados. Realizando una comparativa entre las dos posibles implementaciones, se observa como los resultados obtenidos para el primer nivel son prácticamente idénticos en ambos casos. Todo y que con la incorporación del segundo nivel, se logra disminuir la tasa de fallos para DTLB en el primer nivel. Apreciando la figura 67, la implementación con TLB en L2 al disponer de un tamaño muy superior que con el que cuenta el de L1, es evidente que la probabilidad de fallos de L2 se verá afectada, de forma negativa, aumentando. Por último cabe mencionar que para cualquiera de las dos posibles configuraciones, se consigue mejoría en el número de aciertos a medida que se aumente el tamaño total del TLB. Aunque si bien para el caso de contar sólo con L1 la mejoría es progresiva desde el primer momento, no ocurre igual con L2 donde si bien tiende a una paulatina disminución, al alcanzar el tamaño máximo se produce un ligero aumento. 139
PFC: Análisis TLB – Mónica Larruy Carrete 7.9.1.3.
Tiempo de acceso Figura 69: Comparativa tiempo de acceso SPECINT bzip con y sin TLB L2 Tamaño total TLB (bytes) T. acceso sin L2
128 256 512 1024 2048 3.5254 2.0623 1.276 0.6742 0.3301 Tamaño total TLB (bytes)
T. acceso con L2 384 = (L2:256 – L1:128)
768 = (L2:512 – L1:256)
1536 = (L2:1024 – L1:512)
3072 = (L2: 2048 – L1:1024)
6144 = (L2: 4096 – L1:2048 )
1.3016 0.6898 0.34 0.1592 0.1064 Tabla 24: Valores tiempo acceso SPECINT bzip en función del TLB Hay que mencionar que para ambas implementaciones, se conseguirá mejorar el tiempo medio de acceso a medida que se vea aumentado el tamaño total del TLB. Si se dispusiese únicamente de la gráfica referente a la tasa de fallos del anterior apartado, no se conseguiría distinguir la mejora que se experimenta con la implantación del TLB de segundo nivel. Para ser conscientes de dicha mejoría basta con observar la figura 69. Más detalladamente, a partir de la tabla 24, se distingue como el tiempo de acceso sin L2 es casi el doble que el que se consigue con la especificación con L2. El tiempo de acceso demuestra lo que se había comentado en el apartado referente al IPC, ya que se conseguía mejorar al doble con L2, ello queda remarcado con los valores obtenidos para el tiempo de acceso, donde también se sigue la misma línea de evolución. Concretamente, para este estudio la mejora que se logra es de una reducción de media de 1.05 ns. Si bien la mejoría más destacable se experimenta para el TLB de 128 bytes; 2.224 ns, para el resto de tamaños también se logra mejora, pero a medida que crezca el tamaño del TLB ésta será cada vez menor. 140
PFC: Análisis TLB – Mónica Larruy Carrete 7.9.2. gcc 7.9.2.1.
IPC Tamaño
total TLB (bytes) IPC sin L2 128
256
512
1024
2048
0.1493
0.1864
0.2234
0.2501
0.2624
IPC Tamaño total TLB con L2 (bytes) 384 768 1536 3072 6144 0.2123
0.2437
0.2618
0.2984
0.3004
Figura 70: Comparativa IPC SPECINT gcc con y sin TLB L2 Tabla 25: Valores IPC de gcc en función del TLB Al igual que en el SPEC bzip, para gcc se conseguirá aumentar el IPC a medida que crezca el tamaño total del TLB. La mejoría máxima que se alcanza es del orden de 0.11 instrucciones para el caso de no contar con el nuevo nivel y de 0.09 para la configuración con L2. A partir de la figura 70 o bien la tabla 24, se distingue que con TLBs que implementan un segundo nivel se llega a conseguir mayor resultado de IPC que con TLBs de tamaño equivalente que no disponen de L2. Entre un tamaño total de TLB que soporta L2 y uno igual que no incluye L2 la diferencia va en torno a 0.05 instrucciones. Pero se aprecia que a medida que se aumente el tamaño del TLB a penas existirán diferencias entre ambos casos. Un ejemplo de ello es el TLB de 3072 bytes comparado con el de 1024 bytes, ya que la diferencia existente es de 0.0483 instrucciones. Todo y así, de media se logra una mejora de 0.05 instrucciones. 7.9.2.2.
Miss_rate 141
PFC: Análisis TLB – Mónica Larruy Carrete Figura 71: Miss_rate SPECINT gcc para TLB sólo con L1 Figura 72: Miss_rate SPECINT gcc para TLB con L1 y L2 Tamaño total TLB (bytes) DTLB L1 ITLB L1 128 256 512 1024 2048 0.0273 0.0167 0.0167 0.0104 0.0045 0.0034 0.0017 0.0017 0.0004 0.0001 Tabla 26: Valores miss_rate gcc para TLB sólo con L1 Tamaño TLB L2
total TLB (bytes) 384
768
1536
3072
6144
DTLB L1 ITLB L1
0.0267 0.0161 0.0101 0.0064 0.0047 0.0034 0.0017 0.0004 0.0002 0.0001 0.3986
0.3946
0.4423
0.0528
0.0268
Tabla 27: Valores miss_rate gcc para TLB con L1 y L2 Figura 73: Comparativa miss_rate SPECINT gcc con y sin TLB L2 Para cualquiera de las dos posibles configuraciones de TLB destaca la ínfima tasa de fallos para ITLB en comparación con la de datos, la cuál es ciertamente más elevada. Comparando la tabla 26 con la 27, destaca que los valores generados por el ITLB L1 son muy similares entre ellos, basta con observar la tabla 26 donde los tamaños 256 y 512 bytes, así como los sucesivos a éstos. De forma similar ocurre con DTLB L1, donde si bien para los dos primeros tamaños de TLB existe una cierta diferencia, ésta pasa a ser muy parecida para los siguientes valores de TLB. Por lo que respecta a la inserción del TLB L2 despunta su tasa de fallos respecto a la obtenida con L1. Un motivo del alcance de valores más elevados que en L1 está motivado por el hecho de que si bien en un inicio se obtienen valores similares para L1 entre las dos configuraciones, posteriormente pasarán a disminuirse los errores en L1 recayendo así los posibles fallos sobre L2. A partir de la configuración con L2 si se observan ITLB L1 y DTLB L1 se puede distinguir como la progresión de la tasa de fallos de éstos es exponencialmente decreciente, mientras que para L2 es creciente hasta alcanzar el tamaño total de TLB de 1536 bytes, momento en el que se produce una brusca disminución. 142
PFC: Análisis TLB – Mónica Larruy Carrete 7.9.2.3.
Tiempo de acceso Figura 74: Comparativa tiempo de acceso SPECINT gcc con y sin TLB L2 Tamaño total TLB (bytes) T. acceso sin L2
128 256 512 1024 2048 2.7996 1.6556 0.9239 0.5532 0.3918 Tamaño total TLB (bytes)
T. acceso con L2 384 = (L2:256 – L1:128)
768 = (L2:512 – L1:256)
1536 = (L2:1024 – L1:512)
3072 = (L2:2048 – L1:1024)
6144 = (L2:4096 – L1:2048)
1.1301 0.6549 0.4088 0.0344 0.0143 Tabla 28: Valores tiempo acceso SPECINT gcc en función del TLB A partir de la figura 74 destaca la paulatina disminución que se experimenta en cualquiera de las dos configuraciones. Aunque si bien para el tamaño de 3072 bytes (donde L1=1024 bytes) se compara con el de 1024 bytes, se puede apreciar como para el primero de éstos se consigue reducir el tiempo de acceso llegando a un valor muy próximo a cero, mientras que para 1 KB no se experimenta esta cercanía a un valor nulo. Observando la tabla 28 se demuestra como tamaños con idéntica configuración para L1 experimentan mejorías con la incorporación del segundo nivel. Para apreciarlo más detalladamente basta con observar la figura 74, donde se observa como la línea roja que hace referencia a la configuración sin L2 siempre se encuentra por encima de la representante con L2. Concretamente, la mejora que se consigue alcanzar con la incorporación del segundo nivel es de una reducción de 0.6 ns. 143
PFC: Análisis TLB – Mónica Larruy Carrete 7.9.3. gzip 7.9.3.1.
IPC Tamaño
total TLB (bytes) IPC sin L2 128
256
512
1024
2048
0.1728
0.3579
0.6742
1.7448
1.7453
Tamaño IPC total TLB con L2 (bytes) 384 768 1536 3072 6144 0.6408
1.7432
1.7446
1.7454
1.7455
Figura 75: Comparativa IPC SPECINT gzip con y sin TLB L2 Tabla 29: Valores IPC de gzip en función del TLB Para las dos configuraciones, la progresión que se sufre con el aumento del tamaño de TLB es muy semejante. Más detalladamente, para cualquiera de las dos posibles jerarquías se sitúan en un aumento de 1.11 instrucciones. Por otro lado, apreciando la tabla 29 destaca desde el inicio la mejoría que se consigue con la inserción de un segundo nivel de TLB, muestra de ello sería la comparativa entre un tamaño total de 384 bytes con uno de 128, donde la diferencia pasa a ser de un aumento de 0.5 instrucciones. Donde mayor mejora se produce sería el caso de disponer de un TLB de 768 bytes, donde comparado con el valor obtenido con el de 256 bytes, el aumento es de 1.4 instrucciones. Pero no ocurre igual para todos los tamaños, ya que entre los últimos dos tamaños totales de TLB analizados, la diferencia es mínima; sobre unas 0.0005 instrucciones. Por último, mencionar que la mejoría de media que se consigue con L2 es de 0.6 instrucciones respecto a una configuración sin L2. 7.9.3.2.
Miss_rate 144
PFC: Análisis TLB – Mónica Larruy Carrete Figura 76: Miss_rate SPECINT gzip para TLB sólo con L1 Figura 77: Miss_rate SPECINT gzip para TLB con L1 y L2 Tamaño total TLB (bytes) DTLB L1 ITLB L1 128 256 512 1024 2048 0.0652 0.0333 0.0121 0
0
0.0059 0 0 0 0 Tabla 30: Valores miss_rate gzip para TLB sólo con L1 Tamaño TLB L2
total TLB (bytes) 384
768
1536
3072
6144
DTLB L1 ITLB L1
0.0688 0.0341 0.0116 0 0 0.0056 0 0 0 0 0.1403
0.0009
0.0022
0.5706
0.175
Tabla 31: Valores miss_rate gzip para TLB sólo con L1 Figura 78: Comparativa miss_rate SPECINT gzip con y sin TLB L2 Por lo que respecta al primer nivel, tanto de datos como de instrucciones, para el caso de contar con o sin L2 se obtienen valores muy pequeños, y todo ser muy parecidos entre las dos configuraciones, con la incorporación de L2 se logra en algunos casos una mínima mejora. Para la mayoría de casos el ITLB no presenta tasa de fallos, mientras que el DTLB está muy cercano a conseguir un miss_rate nulo. Esta circunstancia se conseguirá a medida que se aumente el tamaño total del TLB. Nuevamente, la incorporación del nuevo nivel es el que genera el mayor número de fallos. Concretamente, para el caso de 3072 bytes, al no producirse ningún fallo para ITLB y DTLB del primer nivel, todos los fallos recaen en el segundo nivel, de allí que sea un número tan elevado en comparación con los tamaños anteriores a éste. Sin embargo, si se observa el caso de 6144 bytes, se puede distinguir la gran disminución producida con el anterior tamaño estudiado. 145
PFC: Análisis TLB – Mónica Larruy Carrete 7.9.3.3.
Tiempo de acceso Figura 79: Comparativa tiempo de acceso SPECINT gzip con y sin TLB L2 Tamaño total TLB (bytes) T. acceso sin L2
128 256 512 1024 2048 4.436 1.654 0.6044 0.0014 0.0012 Tamaño total TLB (bytes)
T. acceso con L2 384 = (L2:256 – L1:128)
768 = (L2:512 – L1:256)
1536 = (L2:1024 – L1:512)
3072 = (L2:2048 – L1:1024)
6144 = (L2: 4096 – L1:2048 )
0.6749 0.01498 0.0059 0.0008 0.0002 Tabla 32: Valores tiempo acceso SPECINT gzip en función del TLB A partir de la figura 79 se aprecia la evolución exponencialmente decreciente que se sufre con el aumento del tamaño del TLB. Destaca como para los dos primeros tamaños totales de TLB se consigue un tiempo de acceso relativamente elevado en comparación con los tamaños sucesivos. Será con 512 bytes en L1 del TLB para la configuración con L2 y en 1024 bytes para el caso de no contar con L2, donde se comenzarán a aproximar a tiempos de acceso prácticamente nulos. Comparando las dos posibilidades, con L2 se consigue una mejora de media de 1.2 ns menos que sin L2. La mayor mejoría que se experimenta es la generada para el tamaño de 128 bytes en L1. Basta con comparar el valor obtenido para el caso de 128 bytes y el de 384. Tal como se remarca en la tabla 32, la diferencia pasa a ser superior a 3.5 ns. Por su parte, los casos antagónicos serían el de contar con un TLB en L1 de 2048 ó 6144 bytes, ya que en contraste sólo se consigue optimizar 0.0006 ns. 146
PFC: Análisis TLB – Mónica Larruy Carrete 7.9.4. mcf 7.9.4.1.
IPC Tamaño total TLB (bytes) IPC sin L2 128
256
512
1024
2048
0.1003
0.1146
0.1263
0.133
0.1369
Tamaño IPC total TLB con L2 (bytes) 384 768 1536 3072 6144 0.1217
0.1306
0.1362
0.1428
0.1472
Figura 80: Comparativa IPC SPECINT mcf con y sin TLB L2 Tabla 33: Valores IPC de mcf en función del TLB A medida que crezca el tamaño del TLB también lo hará el IPC. Aunque concretamente para este SPEC la mejora máxima alcanzada pasa a ser sólo de 0.03 instrucciones, lo que demuestra que si se considerase únicamente conseguir mejorar el IPC no interesaría aumentar el tamaño del TLB. En cuanto a lo referente a la incorporación de un nuevo nivel de TLB, si bien se consiguen ciertas mejorías que sin L2, éstas son mínimas. Prueba de ello es que la diferencia existente entre la mayor y la menor mejora es de entre 0.015 instrucciones para el caso de no contar con L2 y de 0.025 instrucciones para la otra implementación. 7.9.4.2.
Miss_rate Figura 81: Miss_rate SPECINT mcf para TLB sólo con L1 Figura 82: Miss_rate SPECINT mcf para TLB con L1 y L2 147
PFC: Análisis TLB – Mónica Larruy Carrete Tamaño total TLB (bytes) DTLB L1 ITLB L1 128 256 512 1024 2048 0.1088 0.0886 0.073 0.0621 0.0524 0.0001 0 0 0 0 Tabla 34: Valores miss_rate mcf para TLB sólo con L1 Tamaño TLB L2
total TLB (bytes) 384
768
1536
3072
6144
DTLB L1 ITLB L1
0.1091 0.0889 0.0731 0.0623 0.0526 0.0001 0 0 0 0 0.6672
0.6984
0.7161
0.488
0.261
Tabla 35: Valores miss_rate mcf para TLB con L1 y L2 Figura 83: Comparativa miss_rate SPECINT mcf con y sin TLB L2 Para el caso de no contar con el segundo nivel de TLB se experimenta una evolución decreciente desde el primer momento. Esta circunstancia no sucede en la otra configuración, ya que desde el primer valor hasta 1536 el TLB en L2 sufre un ligero aumento, y será a partir de este valor donde se producirá un claro descenso. Pero en cambio, los TLBs en L1 tendrán la misma progresión decreciente que el caso de no contar con TLB de L2. Los valores de los TLBs en el primer nivel (tanto datos como instrucciones) son muy cercanos a cero, especialmente el ITLB, donde si bien inicialmente la tasa de fallos es mínima para ambos casos, con un ligero aumento del tamaño total del TLB pasa a ser nulo. Por su parte, el TLB en L2 es el que mayor número de fallos produce. 148
PFC: Análisis TLB – Mónica Larruy Carrete 7.9.4.3.
Tiempo de acceso Figura 84: Comparativa tiempo de acceso SPECINT mcf con y sin TLB L2 Tamaño total TLB (bytes) T. acceso sin L2
128 256 512 1024 2048 4.4033 4.377 3.6232 3.0878 2.6079 Tamaño total TLB (bytes)
T. acceso con L2 384 = (L2:256 – L1:128)
768 = (L2:512 – L1:256)
1536 = (L2:1024 – L1:512)
3072 = (L2:2048 – L1:1024)
6144 = (L2:4096 – L1:2048 )
3.6536 3.1188 2.6355 1.5428 0.7086 Tabla 36: Valores tiempo acceso SPECINT mcf en función del TLB Observando la figura 84 se distingue la mejora que se consigue en el tiempo medio de acceso con la inserción del nuevo nivel, ya que tal como se demuestra en la gráfica, la línea referente al TLB con L2 siempre toma valores más pequeños (requiere menor tiempo para acceder) que los que se alcanza sin L2 (línea roja). A partir de la tabla 36 destaca cómo mayor sea el tamaño del TLB mayor será la diferencia entre las dos posibles implementaciones. El caso extremo lo encontramos para el tamaño del TLB en L1 igual a 2048 bytes, donde se consigue reducir el tiempo de acceso a más de la mitad. En total, se logra disminuir el tiempo medio de acceso con la incorporación del L2 en 1.3 ns. 149
PFC: Análisis TLB – Mónica Larruy Carrete 7.9.5. vortex 7.9.5.1.
IPC Figura 85: Comparativa IPC SPECINT vortex con y sin TLB L2 Tamaño
total TLB (bytes) IPC sin L2 128
256
512
1024
2048
0.0946
0.2059
0.2882
0.4025
0.4696
Tamaño IPC total TLB con L2 (bytes) 384 768 1536 3072 6144 0.2177
0.325
0.4449
0.5184
0.5757
Tabla 37: Valores IPC de vortex en función del TLB Para los dos casos se sufre un progresivo crecimiento, aunque éste no es muy remarcado, ya que como máximo se aumentan entorno a 0.36 instrucciones más entre los casos extremos. De media se consigue una mejora de 0.13 instrucciones con la incorporación del TLB de L2. Y para este SPEC independientemente del tamaño total del TLB, el IPC que se consigue mejorar es para cada tamaño de unas 0.12 instrucciones. 7.9.5.2.
Miss_rate Figura 86: Miss_rate SPECINT vortex para TLB sólo con L1 Figura 87: Miss_rate SPECINT vortex para TLB con L1 y L2 150
PFC: Análisis TLB – Mónica Larruy Carrete Tamaño total TLB (bytes) DTLB L1 ITLB L1 128 256 512 1024 2048 0.0775 0.0238 0.0149 0.0095 0.0064 0.0103 0.006 0.0029 0.0007 0 Tamaño TLB L2
total TLB (bytes) 384
768
1536
3072
6144
0.3271
0.4639
0.3696
0.3678
0.2542
DTLB L1 ITLB L1
0.0795 0.0239 0.015 0.0096 0.0064 0.0102 0.006 0.0029 0.0007 0 Tabla 38: Valores miss_rate vortex para TLB sólo con L1 Tabla 39: Valores miss_rate vortex para TLB con L1 y L2 Figura 88: Comparativa miss_rate SPECINT vortex con y sin TLB L2 Considerando únicamente el primer nivel de TLB, la tasa de fallos experimenta una suave disminución. Y será con valores de TLB elevados donde mejores resultados se obtengan, porque pasa a ser prácticamente nulo el número de fallos que se den por acceso. Por lo que respecta al TLB unificado en el segundo nivel, apreciando la figura 87, en un inicio se da una evolución decreciente, pero con el tamaño de 768 bytes se corta para pasar a crecer. A partir de este punto, la tasa de fallos que se observa es de valores muy similares a los obtenidos con los dos primeros tamaños de TLB. Comparando las tablas 38 y 39 cabe mencionar la gran similitud existente en la tasa de fallos obtenida para el primer nivel de TLB independientemente de la jerarquía utilizada. La diferencia entre ambas radica en la incorporación del TLB en L2, ya que será el que presente peores resultados. 151
PFC: Análisis TLB – Mónica Larruy Carrete 7.9.5.3.
Tiempo de acceso Figura 89: Comparativa tiempo de acceso SPECINT vortex con y sin TLB L2 Tamaño total TLB (bytes) T. acceso sin L2
128 256 512 1024 2048 7.9777 2.9423 1.6956 0.8847 0.5191 Tamaño total TLB (bytes)
T. acceso con L2 384 = (L2:256 – L1:128)
768 = (L2:512 – L1:256)
1536 = (L2:1024 – L1:512)
3072 = (L2:2048 – L1:1024)
6144 = (L2:4096 – L1:2048 )
2.727 1.3879 0.6442 0.3337 0.1368 Tabla 40: Valores tiempo acceso SPECINT vortex en función del TLB Si bien en el apartado anterior no se podía deducir la gran mejora que supone la incorporación de un nuevo nivel al TLB, en la figura 89 queda remarcada con el primer tamaño de TLB estudiado, ya que se consigue reducir en más de 5 ns el tiempo de acceso. Todo y ser una gran mejora, ésta no se hace tan remarcada para el resto de casos. Un ejemplo de ello sería el tamaño del TLB de 2KB en el primer nivel donde sólo se disminuye en 0.4 ns Todo y así, de media se logra una reducción de 0.6 ns. Ello hace evidente como el gran peso de la mejora se consigue con el primer tamaño de TLB estudiado; 128 bytes. 152
PFC: Análisis TLB – Mónica Larruy Carrete 7.9.6. vpr 7.9.6.1.
IPC Tamaño total TLB (bytes) IPC sin L2 128
256
512
1024
2048
0.1229
0.222
0.3051
0.3699
0.4453
Tamaño IPC total TLB con L2 (bytes) 384 768 1536 3072 6144 0.282
0.3621
0.4439
0.4635
0.5068
Figura 90: Comparativa IPC SPECINT vpr con y sin TLB L2 Tabla 41: Valores IPC de vpr en función del TLB A partir la figura 90, destaca como el IPC con la inserción de un TLB en L2 (línea azul) siempre es superior a la que no cuenta con él (línea roja), demostrando así que incluyendo un nuevo nivel para el TLB se logra mayor número de IPC. Todo y que la mejoría experimentada no es muy elevada, de media se logra un aumento de 0.1 instrucciones. Para este SPEC no hay ningún tamaño de TLB que destaque en la mejora conseguida, ya que todos consiguen unos valores muy próximos entre sí. 7.9.6.2.
Miss_rate Figura 91: Miss_rate SPECINT vpr para TLB sólo con L1 Figura 92: Miss_rate SPECINT vpr para TLB con L1 y L2 153
PFC: Análisis TLB – Mónica Larruy Carrete Tamaño total TLB (bytes) DTLB L1 ITLB L1 128 256 512 1024 2048 0.1245 0.0658 0.0397 0.0264 0.0098 0.002 0 0 0 0 Tabla 42: Valores miss_rate vpr para TLB sólo con L1 Tamaño TLB L2
total TLB (bytes) 384
768
1536
3072
6144
DTLB L1 ITLB L1
0.1246 0.0661 0.0395 0.0262 0.0001 0.0021 0 0 0 0 0.3123
0.398
0.2477
0.1969
0.0097
Tabla 43: Valores miss_rate vpr para TLB con L1 y L2 Figura 93: Comparativa miss_rate SPECINT vpr con y sin TLB L2 De las tablas 42 y 43 destaca como el ITLB consigue una tasa de fallos muy baja, todo y que para el primer o segundo tamaño de TLB es muy cercana a cero, no se convertirá en un valor nulo hasta posteriores tamaños. En cuanto al DTLB, comparando una implantación de TLB con otra, se observa cómo se obtienen valores prácticamente idénticos para los dos casos. Si bien para los dos primeros tamaños de TLB, con la configuración con L2 se experimentan 0.001 instrucciones más, a partir de los siguientes tamaños pasarán a reducirse mínimamente. Nótese que para el tamaño de 6144 bytes, se consigue exactamente la misma tasa de fallos entre TLB L2 y DTLB L1 que para el TLB de 2048 bytes sólo en el DTLB L1. Si bien este último alcanza un valor de 0.0098, con la otra configuración entre los dos niveles se obtendrá el mismo resultado. Ello es debido a que si bien el primer nivel se ve liberado de fallos al recurrir al segundo nivel, únicamente genera 0.0001, es L2 el que lógicamente más fallos producirá. De nuevo, el TLB correspondiente al segundo nivel es el poseedor de la mayor tasa de fallos. Inicialmente sufre una cierta estabilidad, pero al llegar al último tamaño de 768 bytes se genera un pequeño aumento. Será a partir de este tamaño de TLB donde se inicie la disminución de fallos. 154
PFC: Análisis TLB – Mónica Larruy Carrete 7.9.6.3.
Tiempo de acceso Figura 94: Comparativa tiempo de acceso SPECINT vpr con y sin TLB L2 Tamaño total TLB (bytes) T. acceso sin L2
128 256 512 1024 2048 15.8167 8.2281 4.9584 3.2979 1.2251 Tamaño total TLB (bytes)
T. acceso con L2 384 = (L2:256 – L1:128)
768 = (L2:512 – L1:256)
1536 = (L2:1024 – L1:512)
3072 = (L2: 2048 – L1:1024)
6144 = (L2: 4096 – L1:2048 )
2.1172 1.223 0.5015 0.2664 0.0039 Tabla 44: Valores tiempo acceso SPECINT vpr en función del TLB En la figura 94 se aprecia como desde el primer tamaño de TLB comparado se logra una gran mejoría con la incorporación de un segundo nivel en el TLB. Basta con comparar el tamaño de 128 bytes en L1 en ambos casos. A partir de este ejemplo, se consigue reducir el tiempo de acceso medio en prácticamente 14 ns. Aunque es el tamaño donde más mejoras se consiguen, para los posteriores tamaños también se producirán disminuciones, todo y que no serán tan notables como en este primer caso. Ello es debido a que a medida que se vaya aumentando el tamaño total del TLB, es menos costoso acceder a él. Todo y así, de media se consigue una reducción de 6 ns. 155
PFC: Análisis TLB – Mónica Larruy Carrete 7.9.7. art 7.9.7.1.
IPC Tamaño total TLB (bytes) IPC sin L2 128
256
512
1024
2048
0.1042
0.1366
0.1623
0.1838
0.1952
Tamaño IPC total TLB con L2 (bytes) 384 768 1536 3072 6144 0.1624
0.1837
0.1952
0.1982
0.2004
Figura 95: Comparativa IPC SPECFP art con y sin TLB L2 Tabla 45: Valores IPC de art en función del TLB Para el SPEC art en punto flotante, no se consigue lograr un gran número de instrucciones por ciclo con ninguna de las dos posibles jerarquías de TLB. Entre los casos extremos, como serían el menor tamaño de TLB y el máximo, se consigue una mejora de apenas 0.1 instrucciones más. Comparando las dos configuraciones de TLB, si bien en un inicio se consigue una cierta mejoría; 0.06 instrucciones más, ésta se irá reduciendo a medida que se vea aumentado el tamaño total del TLB. Todo y así, se logran 0.04 instrucciones de media más por ciclo, con la incorporación de un segundo nivel de TLB. 7.9.7.2.
Miss_rate Figura 96: Miss_rate SPECFP art para TLB sólo con L1 Figura 97: Miss_rate SPECFP art para TLB con L1 y L2 156
PFC: Análisis TLB – Mónica Larruy Carrete Tamaño total TLB (bytes) DTLB L1 ITLB L1 128 256 512 1024 2048 0.0482 0.0825 0.0304 0.0196 0.0144 0.002 0 0 0 0 Tabla 46: Valores miss_rate art para TLB sólo con L1 Tamaño TLB L2
total TLB (bytes) 384
768
1536
3072
6144
DTLB L1 ITLB L1
0.0769 0.0456 0.0292 0.0191 0.0014 0 0 0 0 0 0.3949
0.4295
0.4954
0.5012
0.007
Tabla 47: Valores miss_rate art para TLB con L1 y L2 Figura 98: Comparativa miss_rate SPECFP art con y sin TLB L2 La evolución experimentada en L1 por cada una de las implementaciones de TLB es bastante diferente. Basta con observar la figura 96. En ella, si bien se esperaba una disminución progresiva desde el valor inicial para DTLB L1, no sucede así, ya que para el valor de 256 bytes se experimenta un aumento en comparación con el resto de valores. Pero será a partir de valores sucesores a éste donde se producirá la esperada evolución decreciente. Por parte de la configuración del TLB con L2, destaca que para todos los tamaños de TLB estudiados para el ITLB en L1 se consigue reducir la tasa de fallos a cero, mientras que para el DTLB en L1 será muy cercana a valores nulos a medida que crezca el tamaño del TLB. Para prácticamente todos los casos estudiados cabe destacar como en el primer nivel en la implementación con L2 se da una cierta reducción para DTLB e ITLB en comparación a la configuración sin L2. Este hecho motivará, que si bien L1 ve reducida su tasa de fallos, L2 por su parte la verá aumentada. En cuanto al TLB en L2, es el que peores resultados consigue. Si bien con su TLB en L1 se consigue una reducción asociada al aumento del TLB, en el TLB en L2 sucederá todo lo contrario, cuanto mayor sea el tamaño de TLB mayor será también la tasa de fallos. Aunque con tamaños de 6144 bytes se logra una gran reducción en comparación con tamaños anteriores. 157
PFC: Análisis TLB – Mónica Larruy Carrete 7.9.7.3.
Tiempo de acceso Figura 99: Comparativa tiempo de acceso SPECFP art con y sin TLB L2 Tamaño total TLB (bytes) T. acceso sin L2
128 256 512 1024 2048 10.3164 6.0259 3.806 2.448 1.8054 Tamaño total TLB (bytes)
T. acceso con L2 384 = (L2:256 – L1:128)
768 = (L2:512 – L1:256)
1536 = (L2:1024 – L1:512)
3072 = (L2: 2048 – L1:1024)
6144 = (L2:4096 – L1:2048 )
1.8574 1.1971 0.8803 0.5823 0.0126 Tabla 48: Valores tiempo acceso SPECFP art en función del TLB De la figura 99 se puede extraer como principal conclusión la gran mejoría que se logra con la incorporación de un segundo nivel para TLB, ya que la línea que representa a la configuración con L2 (azul) siempre se encuentra muy por debajo de la que asociada a la implantación sin L2 (roja), y en ningún punto se llegan a cruzar. Ello equivale a decir que no presentan resultados similares ninguna de ellas. Más detalladamente se pueden observar los resultados conseguidos para cada una de las posibles jerarquías de TLB en la tabla 48. En ella, destaca la gran reducción experimentada para el nivel uno con 128 bytes, ya que la diferencia entre ambas es de 8.5 ns. Si bien para los posteriores valores de TLB en L1 no se generan reducciones tan elevadas como ésta, serán más discretas, especialmente en los últimos casos. Aún así, con la inserción de un segundo nivel, se consigue de media una disminución de 4 instrucciones. 158
PFC: Análisis TLB – Mónica Larruy Carrete 7.9.8. equake 7.9.8.1.
IPC Tamaño total TLB (bytes) IPC sin L2 Tamaño total TLB (bytes) IPC con L2 128 256 512 1024 2048 0.1629
0.3101
0.4089
0.6628
0.8147
384
768
0.4003
0.6632
0.8155
0.9419
1.0209
1536
3072
6144
Figura 100: Comparativa IPC SPECFP equake con y sin TLB L2 Tabla 49: Valores IPC de equake en función del TLB Con la implantación del segundo nivel de TLB se consigue una cierta mejoría respecto a una que cuente únicamente con L1. Entre los casos extremos de TLB la diferencia máxima alcanzada para ambos casos es de 0.6 instrucciones. Todo y no experimentar grandes mejoras la inserción de un segundo nivel, de media se alcanzan un aumento de 0.32 instrucciones estando presente el nuevo nivel de TLB. La mayor mejoría se alcanza con el tamaño de TLB en L1 de 512 bytes, donde se logra una mejoría de 0.4 instrucciones, todo y no ser muy destacable, en comparación con el resto de casos es una mejora importante. 7.9.8.2.
Miss_rate Figura 101: Miss_rate SPECFP equake para TLB sólo con L1 Figura 102: Miss_rate SPECFP equake para TLB con L1 y L2 159
PFC: Análisis TLB – Mónica Larruy Carrete Tamaño total TLB (bytes) DTLB L1 ITLB L1 128 256 512 1024 2048 0.074 0.0363 0.0239 0.0091 0.0047 0.0007 0 0 0 0 Tamaño TLB L2
total TLB (bytes) 384
768
1536
3072
6144
0.3048
0.2426
0.1935
0.2466
0.2407
DTLB L1 ITLB L1
0.0756 0.0368 0.024 0.0092 0.0048 0.0007 0 0 0 0 Tabla 50: Valores miss_rate equake para TLB sólo con L1 Tabla 51: Valores miss_rate equake para TLB con L1 y L2 Figura 103: Comparativa miss_rate SPECFP equake con y sin TLB L2 Para los dos casos estudiados de configuración de TLB, para ITLB y DTLB en L1 se consigue exactamente la misma tasa de fallos, basta con observar las tablas 50 y 51. En ambos casos, se genera una gradual disminución con el aumento del TLB. Esta evolución se encuentra asociada con el correspondiente aumento del tamaño total del TLB. Por lo que respecta al TLB en L2, nuevamente, es el TLB con peores resultados obtenidos, ya que en comparación con el primer nivel, la tasa de fallos es ligeramente superior. 160
PFC: Análisis TLB – Mónica Larruy Carrete 7.9.8.3.
Tiempo de acceso Figura 104: Comparativa tiempo de acceso SPECFP equake con y sin TLB L2 Tamaño total TLB (bytes) T. acceso sin L2
128 256 512 1024 2048 9.3358 4.5409 2.9856 1.1416 0.5911 Tamaño total TLB (bytes)
T. acceso con L2 384 = (L2:256 – L1:128)
768 = (L2:512 – L1:256)
1536 = (L2:1024 – L1:512)
3072 = (L2: 2048 – L1:1024)
6144 = (L2: 4096 – L1:2048 )
1.343 0.5046 0.2635 0.1275 0.0648 Tabla 52: Valores tiempo acceso SPECFP equake en función del TLB A partir de la figura 104 se observa a simple vista como los resultados de los tiempos medio de acceso sin un segundo nivel de TLB son mucho peores que en el caso de introducir éste nuevo nivel. En ningún momento, se llegan a cruzar las líneas correspondientes a las dos posibles jerarquías, lo que demuestra que los resultados entre ambas no son nada similares. En cuanto a la tabla 52, se destacan con mayor detalle los valores obtenidos para cada caso. Al igual que en anteriores SPECs, la mejor mejoría se produce en el primer caso; tamaño TLB en L1 de 128 bytes, donde se da una diferencia de prácticamente 8 ns. El correspondiente aumento del tamaño total del TLB conlleva a una disminución en el tiempo de acceso al mismo, por lo que no se generarán mejoras tan destacadas como la producida para el primer caso. Aún así, en el caso de disponer con L2 se consigue una reducción de 4 ns. 161
PFC: Análisis TLB – Mónica Larruy Carrete 7.9.9. mesa 7.9.9.1.
IPC Tamaño total TLB (bytes) IPC sin L2 Tamaño total TLB (bytes) IPC con L2 128
256
512
1024
2048
0.159 0.4243 0.7189 1.0277 1.0823 384 768 1536 3072 6144 0.5889
1.0188
1.0791
1.1098
1.1149
Figura 105: Comparativa IPC SPECFP mesa con y sin TLB L2 Tabla 53: Valores IPC de mesa en función del TLB La evolución experimentada para cualquiera de los dos casos estudiados es muy similar. Todo y que la incorporación del segundo nivel supone una cierta mejora. La muestra más destacable de ello se puede encontrar en el primer caso con un tamaño de 128 bytes, ya que la diferencia para este caso es de 0.44 instrucciones. Mientras que para el caso extremo, tamaño de 6144 bytes, la resta entre ambos es de apenas 0.03 instrucciones. Ello demuestra como el progresivo aumento del tamaño total del TLB supondrá una gran mejora, para ambas configuraciones, en el IPC logrado. Para este SPEC, concretamente se logra una mejoría de media de aproximadamente 0.3 instrucciones. 7.9.9.2.
Miss_rate Figura 106: Miss_rate SPECFP mesa para TLB sólo con L1 Figura 107: Miss_rate SPECFP mesa para TLB con L1 y L2 162
PFC: Análisis TLB – Mónica Larruy Carrete Tamaño total TLB (bytes) DTLB L1 ITLB L1 128 256 512 1024 2048 0.0751 0.0277 0.0096 0.0022 0.0015 0.0029 0 0 0 0 Tamaño TLB L2
total TLB (bytes) 384
768
1536
3072
6144
0.1563
0.079
0.1529
0.4268
0.5734
DTLB L1 ITLB L1
0.0778 0.0278 0.0096 0.0021 0.0014 0.0029 0 0 0 0 Tabla 54: Valores miss_rate mesa para TLB sólo con L1 Tabla 55: Valores miss_rate mesa para TLB con L1 y L2 Figura 108: Comparativa miss_rate SPECFP mesa con y sin TLB L2 A partir de las tablas 54 y 55, destaca como los valores obtenidos para el primer nivel sin importar el tipo de configuración empleada son prácticamente idénticos. Si bien para ITLB en L1 se inicia con valores muy próximos a cero y se continúa con una tasa de fallos nula, para el DTLB en L1 se irán aproximando a valores cercanos a cero a medida que crezca el tamaño total del TLB. En cuanto al nuevo TLB en L2 supone la peor tasa de fallos en comparación con el del primer nivel. La disminución que experimenta es totalmente irregular, ya que si bien en un inicio se da una evolución decreciente, en el momento de alcanzar el tamaño de TLB de 1536 bytes se verá aumentada. 163
PFC: Análisis TLB – Mónica Larruy Carrete 7.9.9.3.
Tiempo de acceso Figura 109: Comparativa tiempo de acceso SPECFP mesa con y sin TLB L2 Tamaño total TLB (bytes) T. acceso sin L2
128 256 512 1024 2048 9.7493 3.4598 1.1949 0.2728 0.1831 Tamaño total TLB (bytes)
T. acceso con L2 384 = (L2:256 – L1:128)
768 = (L2:512 – L1:256)
1536 = (L2:1024 – L1:512)
3072 = (L2:2048 – L1:1024)
6144 = (L2:4096 – L1:2048)
0.9177 0.1567 0.0999 0.0606 0.0548 Tabla 56: Valores tiempo acceso SPECFP mesa en función del TLB Debido a la gran diferencia existente en el primer valor estudiado; 128 bytes en L1, a partir de la figura 109 no queda remarcada la verdadera mejora que se logra con la incorporación del segundo nivel de TLB. Para ello se aconseja observar la tabla 54, donde se adjuntan los valores obtenidos para cada uno de los tamaños de TLB estudiados. A partir de ésta, destaca la gran disminución que se alcanza con 128 bytes, ya que la reducción con un TLB que cuenta con L2 pasa a ser de 8.8 ns. A medida que se aumente el tamaño total del TLB se verá disminuido el tiempo medio de acceso a él, lo que genera que las diferencias entre una configuración y otra no sean tan remarcadas como con tamaños pequeños. A pesar de ello, cabe destacar que para este SPEC se consigue de media una disminución de 2.75 ns. 164
PFC: Análisis TLB – Mónica Larruy Carrete 7.9.10.
Conclusiones estudio dinámico En este apartado se pasarán a exponer el conjunto de conclusiones globales extraídas del estudio dinámico independientemente del SPEC analizado. A lo largo de los análisis realizados sobre los diferentes SPECs se ha podido apreciar como la evolución que se genera para cada uno de los parámetros examinados; IPC, miss_rate y tiempo medio de acceso, es idéntica. Si únicamente se contase con la gráfica asociada a la tasa de fallos no se podría demostrar los efectos de mejora que supone la incorporación de un segundo nivel de TLB, ya que para este caso el TLB en L2 es el que cuenta con los peores resultados, mientras que el DTLB e ITLB en L1, independientemente de la jerarquía de TLB, producen resultados prácticamente idénticos. En algunos SPECs, se llega a observar como los alcances para L1 disponiendo de L2 se ven reducidos que sin L2. Este motivo provocará que si bien L1 se vea disminuido, será en L2 donde se genere un aumento, ya que el peso pasa a recaer sobre él en el caso de que L1 no disponga de la dirección solicitada. Basta con examinar las gráficas y tablas correspondientes al estudio del IPC para apreciar como con idénticos tamaños de TLB para el primer nivel, se consigue para el caso de contar con un segundo nivel producir siempre mayor número de instrucciones. Al igual ocurre con el tiempo medio de acceso. Aunque para este caso, no se logra un aumento, lo que supondría un pésimo resultado, sino una clara y pronunciada disminución en el tiempo medio de acceso al TLB. Cabe destacar que tanto para el estudio del IPC como para el del tiempo de acceso, las mayores mejorías se experimentan en los primeros tamaños totales de TLB estudiados, concretamente para L1 con 128 bytes. A medida que se aumenta dicho tamaño se continúan produciendo importantes mejorías, pero éstas no son tan remarcadas como las iniciales. Así pues, ante todas las anteriores menciones se hace interesante la inserción de un segundo nivel de TLB, ya que se lograrán importantes mejoras. 165
PFC: Análisis TLB – Mónica Larruy Carrete 8. CRONOGRAMA TEMPORAL (diagrama de Gantt) A continuación se muestra el diagrama de tareas temporal para reflejar las fases y su duración empleadas para la realización de este proyecto. Figura 110: Cronograma temporal (diagrama de Gantt) con las diferentes fases en la realización del proyecto
166
PFC: Análisis TLB – Mónica Larruy Carrete La primera fase del proyecto consistió en la búsqueda de información. En ésta, se recopiló información sobre los procesadores superescalares, funcionamiento del TLB, así como implementaciones reales que cuentan con TLB. Paralelamente a esta tarea de búsqueda, se inició lo que sería la documentación. Una vez adquiridos los conocimientos, se siguió con la parte correspondiente al estudio estático, para ello fue necesaria la instalación del simulador CACTI, ya que la versión online con la que se cuenta actualmente no permitía realizar el estudio del TLB. Tras la familiarización con éste, se iniciaron un conjunto de pruebas y se observó que habría que realizar una serie de modificaciones sobre el simulador para poder trabajar con tamaños de caché tan pequeños como son los representados por el TLB. Finalizado el estudio estático, se pasó a la tarea correspondiente al estudio dinámico reflejada por la instalación de SimpleScalar. De esta parte cabe mencionar que inicialmente se llevó a cabo la instalación del simulador sobre una máquina ofrecida por la universidad para la realización de proyectos, pero finalmente por un conjunto de inconvenientes surgidos se optó por instalarlo sobre mi propio ordenador. También decir, que la instalación supuso un gran problema, ya que fueron necesarias un considerable número de modificaciones sobre los ficheros proporcionados por el simulador para conseguir su instalación y posterior ejecución (véase anexo). Tras la instalación de SimpleScalar, se pasó a una primera prueba de contacto. En esta se apreció que los ejecutables benchmarks proporcionados estaban creados para trabajar sobre una arquitectura Alpha y no sobre la nuestra; PISA. Así pues, una primera opción pasó por la creación de unos ejecutables para PISA mediante un compilador diferente al proporcionado inicialmente por SimpleScalar, pero los resultados no fueron los deseados. A raíz de este motivo, se consiguieron obtener dichos ejecutables ya creados a través de la página oficial de SPECs. Conseguidos dichos ejecutables ya se pudo pasar a realizar las primeras pruebas, en las que se probaron con un conjunto de parámetros hasta obtener unos valores correctos y deseados para poder analizar el TLB, sin que siempre se diese una tasa de acierto del 100%. Inicialmente, se optó por probar con tamaños de TLB de 128 bytes a 32 KB. Ello supuso la nueva simulación sobre CACTI para tamaños tan pequeños (de 128 a 512 bytes), trayendo como consecuencia nuevas modificaciones. Si bien las pruebas para 256 y 512 bytes se consiguieron ejecutar, los resultados proporcionados por CACTI fueron totalmente incoherentes y se optaron por descartar. Este es el principal motivo por el que no se puede realizar una comparación total entre los tamaños estudiados por SimpleScalar (de 128 bytes hasta 6144 bytes) y los generados por CACTI (de 1 a 32 KB). 167
PFC: Análisis TLB – Mónica Larruy Carrete Ejecutados los SPECs deseados a partir de una configuración deseada, se pasó al análisis del TLB para la incorporación de un segundo nivel, con el fin de demostrar las mejoras que supone incorporar un nuevo nivel. Este análisis tuvo como consecuencia final, la modificación de uno de los simuladores proporcionados por SimpleScalar; el sim‐outorder. En él se incorporaron todas las variaciones necesarias para soportar un nuevo nivel de TLB, en vez de trabajar con un único nivel, tal y como se estaba realizando hasta este punto. Una vez realizadas dichas modificaciones, se probaron varias configuraciones de TLB hasta obtener una que se ajustaba al objetivo fijado. Esta nueva configuración desembocó en tener que volver a ejecutar los SPECs realizados en una fase previa a ésta sin considerar este segundo nivel. Ello fue debido, a que uno de los parámetros de latencia de memoria considerados inicialmente pasaba ahora a ser un valor demasiado pequeño. Finalmente, nótese que tras la terminación de prácticamente cada una de las tareas se fue realizando en paralelo la documentación del proyecto. Todo y como se hace evidente en la figura 110, las últimas semanas supuso el exclusivo trabajo de la finalización de la misma. 168
PFC: Análisis TLB – Mónica Larruy Carrete 9. CONCLUSIONES El principal objetivo del proyecto consistía en la realización de un análisis sobre el efecto del TLB en el rendimiento del sistema. Así pues se pasó a realizar primeramente un estudio estático del mismo. El objetivo de este análisis se centró en obtener los efectos que suponen la modificación principalmente del tamaño del TLB sobre el tiempo de acceso, área y consumo de los puertos lectura/escritura para los siguientes estudios: ƒ
Estudio del grado de asociatividad {directa,2,4 y 8} ‐
Tiempo de acceso (ns) Los mejores tiempos se consiguen con una asociatividad directa, a su vez es la que sufre más variaciones con el progresivo aumento del tamaño del TLB. Para el resto de grados de asociatividad, la evolución experimentada entre ellos es prácticamente idéntica. Si bien desde 1 hasta 4 KB, la segunda mejor opción pasaría a ser 2‐asoc. A partir de este último valor, los resultados entre 2, 4 y 8‐asoc son muy similares. Finalmente, cabe mencionar que el tiempo de acceso se verá aumentado por el incremento en el grado de asociatividad. Y tal como se esperaba, el crecimiento del TLB estará asociado con el aumento en el tiempo de acceso. ‐
Área (mm2) El área no se ve influenciada por el grado de asociatividad, ya que para un mismo tamaño de TLB con los cuatro posibles grados de asociatividad se obtienen tiempos de acceso análogos. ‐
Consumo lectura/escritura (nJ) Si bien para el tiempo de acceso se hacía evidente que la mejor opción pasaba por usar una asociatividad directa. Para el caso de consumo, tanto para el de lectura como para el de escritura, no es tan evidente esta opción, sino que el consumo obtenido por 1 y 2‐asoc son muy semejantes, todo y que destaca levemente la asociatividad directa. Nótese que, para el consumo, mayor grado de asociatividad supone peores resultados. ƒ
Estudio del tamaño de línea {32, 64, 128 bytes} ‐
Tiempo de acceso (ns) Para TLBs pequeños si hubiese que escoger entre uno de los tamaños de línea analizados, sería irrelevante, debido a que el tiempo de acceso es idéntico. A medida que se incrementa el tamaño del TLB, se aprecia que líneas de 128 bytes serían la mejor opción. Aunque la diferencia no es considerablemente notable. 169
PFC: Análisis TLB – Mónica Larruy Carrete El motivo por el que con un mayor tamaño de línea se consigue menores tiempos de acceso es debido al procesamiento de las mismas. Es decir, cuanto mayor sea la línea más bytes se podrán procesar en un mismo ciclo, y con ello menor será el tiempo de acceso al TLB. ‐
Área (mm2) Los tamaños de línea no afectarán al área. ‐
Consumo lectura/escritura (nJ) El consumo de lectura y el de escritura crecen con el aumento del tamaño de línea. Para los tres casos estudiados de tamaño de línea, la evolución que se sigue en el consumo es prácticamente la misma. ƒ
Estudio de la escala de integración {32, 45, 65, 90 nm} ‐
Tiempo de acceso (ns) Se produce una ligera disminución del tiempo de acceso a medida que tanto la escala de integración como el tamaño del TLB se ven reducidos. Para cualquiera de las cuatro escalas de integración, no se produce un cambio significativo en el tiempo de acceso con el progresivo decremento del tamaño de TLB de 4 KB hasta alcanzar el tamaño de 1 KB. Si bien cabía esperar que la mayor mejora se lograse al pasar de 90 a 65 nm, no ha sido así, sino que se ha producido de 65 a 45 nm. Mientras que el posible paso de 45 a 32 nm, sería inferior a cualquiera de las anteriores disminuciones. ‐
Área (mm2) A diferencia de los anteriores estudios del área, la escala de integración influenciará claramente en el área. En este caso, para mismos tamaños de TLB se logrará menor área con escalas de integración más pequeñas. Por lo que respecta a las escalas de integración, se aprecia que la que sufre diferencias más significativas con el aumento del tamaño de TLB es la de 90 nm, mientras que el caso antagónico se encontraría en la de 32 nm. ‐
Consumo lectura/escritura (nJ) Destaca como a mayor escala de integración y de tamaño de TLB más notable será el consumo de lectura/escritura generado. Dado un mismo tamaño de TLB, el aumento experimentado entre una escala de integración y la inmediatamente superior es prácticamente del doble para todos los casos estudiados. Mientras que para diferentes tamaños con la misma escala de integración, se sigue un crecimiento lineal. 170
PFC: Análisis TLB – Mónica Larruy Carrete ƒ
Estudio del número de puertos {L=1 E=1, L=2 E=1, L=2 E=2, L=4 E=1, L/E=0} ‐
Tiempo de acceso (ns) El número de puertos de lectura y escritura no afectará al tiempo de acceso. Sin embargo para tamaños grandes de TLB, como sería 32 KB, si se llega a producir una ligera diferencia entre los diferentes casos estudiados. ‐
Área (mm2) En los casos estudiados del número de puertos para diferentes tamaños de TLB se sigue un crecimiento exponencial. A medida que se vea aumentado el tamaño del TLB y el del número de puertos, se verá reflejado en el crecimiento del área. ‐
Consumo lectura/escritura (nJ) En general, el consumo de lectura llega a ser prácticamente el doble respecto al de escritura. Si bien el de escritura sigue un comportamiento lineal, el de lectura produce un claro ascenso al pasar de un tamaño de TLB de 16 a 32 KB. Mientras que el consumo previo a un tamaño de 16 KB es muy uniforme. Para tamaños inferiores a éste, se producen ligeras disminuciones. Una vez analizado el TLB desde una perspectiva estática, se optó por incorporar una mejora en el TLB, y con ello en el rendimiento del sistema. Así pues, se optó por la implementación a nivel de software de un nuevo nivel para TLB (L2). Cuando se proponen nuevos esquemas de memoria caché o TLB, su evaluación suele partir de un modelo de procesador convencional y se busca la mejor configuración del esquema, de forma que se minimice el tiempo de ejecución de ciertos programas de prueba. Así pues, se pasó a analizar el TLB desde la perspectiva del estudio dinámico. Para el desarrollo del estudio dinámico, se optó por comparar la implementación con únicamente un nivel (L1) de TLB con uno que dispusiese de L2. Para este último caso, al trabajar con un TLB de segundo nivel, se ha optado por uno unificado. A lo largo de este análisis se optó por estudiar los efectos del TLB sobre el IPC, la tasa de fallos y el tiempo de acceso. Si bien se ha incorporado el estudio de la tasa de fallos, únicamente contando con este análisis no se podría demostrar las mejoras que supone la inserción de L2, debido a que este nivel es el que mayor número de fallos ha generado. Cabe destacar, que para alguna de las pruebas realizadas se puede apreciar como este nuevo nivel supone la reducción de fallos en L1, pero genera como 171
PFC: Análisis TLB – Mónica Larruy Carrete consecuencia un aumento en L2, ya que el peso pasa a recaer sobre él en vez de cómo ocurría anteriormente sobre L1. Por lo que respecta tanto al IPC como a los tiempos de acceso, se observa como con idénticos tamaños de TLB, la inserción de L2 supone un aumento en el número de instrucciones por ciclo y una reducción en los tiempos de acceso. Nótese que tanto para el estudio del IPC como para el del tiempo de acceso, las mayores mejorías se experimentan para pequeños tamaños totales de TLB estudiados, concretamente para L1 con 128 bytes. A medida que se vea aumentado el tamaño del TLB se continúan generando importantes mejorías, pero éstas no son tan remarcadas como las iniciales. Así pues, ante todos los interesantes resultados extraídos a lo largo del proyecto se puede concluir que la inserción de un segundo nivel de TLB se hace muy interesante, ya que se supondría importantes mejoras. 172
PFC: Análisis TLB – Mónica Larruy Carrete 10. RECURSOS UTILIZADOS 10.1. Bibliografía ORTEGA J.; ANGUITA M.; PRIETO A. “Arquitectura de computadores” Ed. Thomson ISBN: 84‐9732‐274‐6 STALLINGS W. “Sistemas Operativos: Principios de diseño e interioridades” Ed. Pearson – Prentice Hall ISBN: 84‐205‐3177‐4 UJALDÓN M. “Arquitectura del PC. Volumen 1: Microprocesadores” Ed. Ciencia‐3 ISBN: 84‐95391‐86‐4 PATTERSON D.; HENNESY J. “Organización y diseño de computadores. La interfaz hardware / software” Ed. McGraw‐Hill ISBN 84‐481‐1829‐4 PATTERSON D.; HENNESY J. “Estructura y diseño de computadores. Intefície circuitería / programación” Ed. Reverté ISBN: 84‐291‐2619‐8 TANENBAUM A. “Sistemas operativos modernos” Ed. Prentice Hall ISBN: 970‐26‐0315‐3 WILTON, S. J. E.; JOUPPI, N. P. “CACTI: An Enhanced Cache Access and Cycle Time Model”. IEEE Journal of Solid State Circuits, 1996 AUSTIN, TODD M. “A User's and Hacker's Guide to SimpleScalar Architectural Research Tool Set”. Intel MicroComputer Research Labs, Gener 1997 AUSTIN, T.; [et al.] “SimpleScalar Tutorial” AUSTIN, T.; LARSON E.; ERNST D. “SimpleScalar: An Infrastructure for Computer System Modeling”. University of Michigan, Febrer 2002 BURGER, D.; AUSTIN, T. M. “The SimpleScalar Tool Set, Version 2.0”. 1997 GONZÁLEZ A. “Tendencias en la Microarquitectura de los Procesadores”. Departamento de Arquitectura de Computadores, Universidad Politécnica de Cataluña, Barcelona, España. ROATTA S.; REXACHS D.; LUQUE E. “Adaptación dinámica de memorias cachés”. Universidad Autónoma de Barcelona, Departamento de Informática, Unidad De Arquitectura de Ordenadores y Sistemas Operativos. Bellaterra, Barcelona, España. CALLAGHAN M.; HOQUE M.; ROTENBERG E. “Level Two Translation Lookaside Buffers” 173
PFC: Análisis TLB – Mónica Larruy Carrete BURGER D.; KÄGI A.; HRISHIKESH M. “Memory Hierarchy Extensions to the SimpleScalar Tool Set”. Tech Report TR99‐25. The University of Texas at Austin. 10.2. Páginas webs 10.2.1.
Gestión de la memoria ‐
http://www.arcos.inf.uc3m.es/~ssoo‐va/ssoo‐va/libro/pdf/cap04.pdf ‐
http://bioinfo.uib.es/~joemiro/teach/infAl/ciclo4/Iglesia.PDF ‐
http://iteso.mx/~miguelbaz/cursos/arqcomp‐2005‐
08/presentaciones/memorganization.pdf ‐
http://wwwdi.ujaen.es/~lina/TemasSO/ADMINISTRACIONDELAMEMORIA/1y2Organizacio
n,GestionyConceptos.SistemasMonoprogramados.htm#organizacion_gestion_conceptos ‐
http://www.infor.uva.es/~fjgonzalez/apuntes_aso/Tema3.pdf ‐
http://atc1.aut.uah.es/~ssootm/Trps/T7_Gestion_de_memoria.pdf ‐
http://www.uhu.es/josem.bravo/ACII/Tema%20II.pdf ‐
http://www.idg.es/pcworld/La_memoria_cache_Conozca_el_funcionamiento_de_la_m/a
rt124276.htm ‐
http://www.monografias.com/trabajos37/memoria‐cache/memoria‐cache2.shtml ‐
http://download.intel.com/museum/sand_to_circuits.pdf 10.2.2.
Paginación, segmentación http://www.atc.us.es/descargas/gm.pdf http://www.mauricio.varea.info/publications/notes/memoria.pdf http://html.rincondelvago.com/tecnicas‐de‐paginacion.html http://nits.com.ar/uadeclasses/clase11.html www.utplonline.edu.ec/cursos/diretorio/apoio_2963_2/pag‐seg.ppt http://luiscm.blogspot.com/2007/05/paginacin.html http://www.inf.udec.cl/~apuente/archivos/Presentaci%F3n%20Trabajo%202.pdf 174
PFC: Análisis TLB – Mónica Larruy Carrete 10.2.3.
Arquitectura superescalar ‐
http://www.chw.net/Manuales/Guias/ ‐
http://209.85.135.104/search?q=cache:e7wlS6cLTrkJ:aulavirtual.uji.es/file.php/2648/Teo
ria/Primer_cuatrimestre/Tema2_superescalares/2_1_introduccion_procesadores_supere
scalares.pdf+que+es+procesador+superescalar&hl=es&ct=clnk&cd=6&gl=es ‐
http://www.ati.es/novatica/2000/145/antgon‐145.pdf ‐
http://courses.ece.uiuc.edu/ece511/papers/Smith.1995.IEEE.pdf ‐
http://www.cag.lcs.mit.edu/6.004/Lectures/lect19/sld014.htm ‐
http://www.frcu.utn.edu.ar/deptos/depto_3/32JAIIO/est/EST_19.pdf ‐
http://www.ldc.usb.ve/~adiserio/ci3811/spim1.html ‐
http://es.wikipedia.org/wiki/Arquitectura_MIPS ‐
http://es.wikipedia.org/wiki/DLX 10.2.4.
TLB ‐
http://www.ac.uma.es/~sromero/so/Capitulo8.pdf ‐
http://www.cag.lcs.mit.edu/6.004/Lectures/lect19 ‐
http://www.wikipedia.es/enciclopedia/TLB ‐
http://www.herrera.unt.edu.ar/arqcom/Diapositivas/Tema14.pdf ‐
http://www2.dis.ulpgc.es/~itisc/Documentacion/Transparencias%20y%20problemas/Tem
a3_4_5_6_memoria/Tema6_memoria_virtual.pdf ‐
http://ditec.um.es/so/web‐0708/apuntes/teoria/tema4.pdf 10.2.5.
‐
Implementaciones reales www.intel.com http://www.macuarium.com/cms/index.php?option=com_content&task=view&id=612&I
temid=98 • Procesador Pentium: Pentium Processor Family Developer's Manual, Volume 1 http://www.herrera.unt.edu.ar/arqcom/Descargas/ProcesadoresIn tel.pdf http://www.alpertron.com.ar/INTEL.PDF ‐
www.amd.com 175
PFC: Análisis TLB – Mónica Larruy Carrete • Procesador Athlon: http://www.amd.com/usen/assetss/content type/white papers and tech_docs/22007.pdf AMD Athlon™ Processor x86 Code Optimization Guide.pdf • Procesador Phenom (multi‐core): http://www.amd.com/usen/assetss/content type/white papers and tech_docs/31116.pdf http://www.chw.net/Revisiones/Procesadores/AMD‐Phenom‐X3‐ 200804231992/1.html http://www.delosperros.com/foro/showthread.php?t=1238 ‐
Comparativa (actual) Intel vs AMD: http://www.techspot.com/espanol/articulos/87‐amd‐
phenom‐desempeno/pagina1.html 10.2.6.
CACTI ‐
http://www.hpl.hp.com/research/cacti/ ‐
http://www.hpl.hp.com/techreports/2008/HPL‐2008‐20.pdf?jumpid=reg R1002 USEN 10.2.7.
SimpleScalar ‐
http://www.simplescalar.com ‐
www.cse.sc.edu/~matthews/Courses/513/Lectures/Lec12‐TLB.ppt ‐
www.ac.usc.es/system/files ‐
www.cs.cinvestav.mx ‐
pages.cs.wisc.edu/~markhill/cs752/Fall2004/includes/ss_tutorial_fall2004.ppt ‐
www.eecg.toronto.edu/~moshovos/ACA07/lecturenotes/simplescalar.ppt ‐
Análisis código SimpleScalar: http://www.cs.virginia.edu/~yw3f/cs757/simplescalar/index.html 10.2.7.1. Instalación ‐
www.capsl.udel.edu/courses/cpeg323/2008/slides/Tutorial0‐323‐08F.ppt ‐
www.student.tue.nl/S/z.ye/links/simplescalar‐3.0/local_copy/simplescalar_install notes. pdf ‐
http://www.studiokhalid.com/simplescalar/simplescalar.htm 176
PFC: Análisis TLB – Mónica Larruy Carrete ‐
http://research.iiit.ac.in/~nayan_mujadiya/multi‐core/simplescalarinstall.html ‐
http://www.kth.se/polopoly_fs/1.17172!simplescalar‐installation‐instructions.pdf 10.3. Software El software empleado a lo largo del proyecto para los diferentes estudios realizados ha sido: ‐
CACTI 4.1 Æ utilizado para el estudio estático: área, consumo y tiempo de acceso en función del grado de asociatividad, tamaño de línea, escala de integración y número de puertos de lectura y escritura. Disponible en: http://www.hpl.hp.com/research/cacti/ ‐
SPEC CPU2000 Æ conjunto de benchmarks aplicados para el estudio dinámico. Aunque si bien se han intentado utilizar no ha sido posible su uso, ya que estaban pensados para una arquitectura Alpha. Disponible en: http://www.spec.org ‐
Benchmarks usados en estudio dinámico Æ ejecutables para arquitectura PISA. Disponibles en: http://www.eecs.umich.edu/mirv/benchmarks/benchmarks.html ‐
SimpleScalar 3.0 Æ usado de cara al estudio dinámico: IPC, tasa de fallos y tiempo medio de acceso en función de los SPECs ejecutados. Disponible en: http://www.simplescalar.com/ 10.4. Hardware Para el estudio dinámico se ha simulado una arquitectura PISA sobre el simulador sim‐outorder. El ordenador sobre el que se han lanzado las simulaciones es un Intel Core2Duo CPU T7100 a 1.80 GHz de frecuencia de reloj con 2 GB RAM. El sistema operativo empleado para las simulaciones es Ubuntu 8.10. 177
PFC: Análisis TLB – Mónica Larruy Carrete ANEXO •
Instalación SimpleScalar Aquí se describen los pasos necesarios para la instalación de SimpleScalar sobre un Ubuntu 5.10. 1) Es necesario obtener los siguientes ficheros: ƒ simplesim‐3v0d.tgz y simpletools‐2v0.tgz, los cuales se pueden conseguir en: http://www.simplescalar.com/tools.html ƒ simpleutils‐990811.tar.gz en http://www.eecs.umich.edu/mirv/ ƒ gcc‐2.7.2.3.ss.tar.gz se pude encontrar en http://arch.cs.ucdavis.edu/RAD/gcc‐
2.7.2.3.ss.tar.gz ƒ flex‐2.5.4a.tar.gz de http://flex.sourceforge.net/ 2) Instalar flex $ cp flex-2.5.4a.tar.gz ~
$ cd ~
$ tar xvfz flex-2.5.4a.tar.gz
$ cd flex-2.5.4
$ ./configure --prefix=/home/tu-loginUser/flex-2.5.4
$ make
$ make install
$ export PATH=/home/tu-loginUser/flex-2.5.4/bin/:$PATH
Comprobación de la correcta instalación de flex: $ flex –-version
Se debe obtener “flex version 2.5.4”. 3) Configurar variables de entorno. $ export IDIR=/home/tu-loginUser/simplescalar
$ export HOST=i686-pc-linux
4) Crear el directorio “simplescalar” por debajo de tu directorio home, y copiar allía los cuatro archivos descargados: $ mkdir $IDIR
$ cp simplesim-3v0d.tgz $IDIR
$ cp simpletools-2v0.tgz $IDIR
178
PFC: Análisis TLB – Mónica Larruy Carrete $ cp simpleutils-990811.tar.gz $IDIR
$ cp gcc-2.7.2.3.ss.tar.gz $IDIR
Comprobar que se dispone de: ‐
f2c‐1994.09.27 (directorio) ‐
glibc‐1.09 (directorio) ‐
simplesim‐3.0 (directorio) ‐
ssbig‐na‐sstrix (directorio) ‐
gcc‐2.7.2.3 (directorio) ‐
Readme.gcc‐2.7.2.3 (fichero) ‐
simpleutils‐990811 (directorio) ‐
sslittle‐na‐sstrix (directorio) 5) Iniciar la instalación de los paquetes en el siguiente orden: a) simpletools: Descomprimir el fichero tar y eliminar (si es necesario) la antigua carpeta de gcc:
$ cd $IDIR
$ tar xvfz simpletools-2v0.tgz
$ rm -rf gcc-2.6.3
b) simpleutils:
$ cd $IDIR/simpleutils
$ tar xvfz simpleutils-990811.tar.gz
$ ./configure --host=$HOST --target=$TARGET --with-gnu-as --with-gnu-ld
--prefix=$IDIR
$ make
PROBLEMA: Se genera el siguiente error: ldlex.l: In function `yy_input':
ldlex.l:589: error: `yy_current_buffer' undeclared (first use in
this function)
ldlex.l:589: error: (Each undeclared identifier is reported only
once)
ldlex.l:589: error: for each function it appears in.)
¿Cómo solucionarlo? Cambiar en "ld/ldlex.l": "if (yy_current_buffer>yy_input_file)" por "if (YY_CURRENT_BUFFER->yy_input_file)"
179
PFC: Análisis TLB – Mónica Larruy Carrete $ make install
c) simplesim:
$ cd $IDIR
$ tar xvfz simplesim-3v0d.tgz
$ cd simplesim-3.0
$ make config-pisa
$ make
Verificación de la instalación de simplesim :
$ cd $IDIR/simplesim-3.0
$ ./sim-outorder tests-pisa/bin.little/test-math > ../output.txt
$ cd ..
$ gedit output.txt
El fichero debe asemejarse a este: pow(12.0, 2.0) == 144.000000
pow(10.0, 3.0) == 1000.000000
pow(10.0, -3.0) == 0.001000
str: 123.456
x: 123.000000
str: 123.456
x: 123.456000
str: 123.456
x: 123.456000
123.456 123.456000 123 1000
sinh(2.0) = 3.62686
sinh(3.0) = 10.01787
h=3.60555
atan2(3,2) = 0.98279
pow(3.60555,4.0) = 169
169 / exp(0.98279 * 5) = 1.24102
3.93117 + 5*log(3.60555) = 10.34355
cos(10.34355) = -0.6068, sin(10.34355) = -0.79486
x
0.5x
x0.5
x
x
0.5x
-1e-17 != -1e-17 Worked!
d) gcc‐2.7.2.3:
$ export PATH=$PATH:/home/tu-loginUser/simplescalar/sslittle-nasstrix/bin
$ ./configure --host=$HOST --target=$TARGET --with-gnu-as --with-gnu-ld
--prefix=$IDIR
$ make LANGUAGES=”C” CFLAGS=”-g -03” CC=”gcc”
180
PFC: Análisis TLB – Mónica Larruy Carrete PROBLEMA: Se generan los siguientes errores: (a)
insn-output.c:675:10: missing terminating " character
insn-output.c: In function `output_110':
insn-output.c:676: error: syntax error before "sll"
insn-output.c:676: error: stray '\' in program
insn-output.c:676: error: stray '\' in program
insn-output.c:676: error: stray '\' in program
insn-output.c:676: error: stray '\' in program
¿Cómo solucionarlo? Cambiar en "insn-output.c" "return "FIXME\n" por "return
"FIXME\n\" (nº de líneas 675,750 y 823) (b)
In file included from ./libgcc2.c:1419:
/cab/cestud/user/mdmafiju/DAT105/simplescalar/sslittle-nasstrix/
include/stdio.h:167: parse error before `void'
¿Cómo solucionarlo? Reemplazar sslittle-na-sstrix/include/sys/cdefs.h con el directorio pacheado "patched". Es decir, actualizar el fichero original cdefs.h mediante
la siguiente comanda:
$ cp $IDIR/gcc-2.7.2.3/patched/sys/cdefs.h $IDIR/sslittle-nasstrix/include/sys
(c)
cxxmain.c:2978: error: conflicting types for ‘malloc’
make: *** [cxxmain.o] Error
¿Cómo solucionarlo? Cambiar en cxxmain.c: Comentar las líneas 2978 y 2979 ( char *
malloc () and char * realloc ()) ( Se necesita aplicar chmod 755 *.* antes de efectuar los cambios) $ make enquire
$ ../simplesim-3.0/sim-safe ./enquire -f > float.h-cross
$ make install LANGUAGES="c"
PROBLEMA: Se generan los siguientes errores: (a)
sendmsg.c:36: parse error
¿Cómo solucionarlo? En objc/sendmsg.c, añadir "#define STRUCT_VALUE 0" en la
línea 35 (Se necesita aplicar chmod 755 *.* antes de efectuar los cambios en objc) , y eliminar las líneas de la 36 a la 40 (inclusivas). (b)
In file included from ./protoize.c:60:
/usr/lib/gcc/i486-linux-gnu/4.1.2/include/varargs.h:4:2: error:
#error "GCC no longer implements <varargs.h>."
/usr/lib/gcc/i486-linux-gnu/4.1.2/include/varargs.h:5:2: error:
181
PFC: Análisis TLB – Mónica Larruy Carrete #error "Revise your code to use <stdarg.h>."
¿Cómo solucionarlo? En protoize.c, reemplazar "#include <varargs.h>" en la línea 60 por "#include <stdarg.h>"
Verificación de la instalación de gcc :
$ cd $IDIR
$ mkdir dev
$ cd dev
$ gedit hola.c
Usar el siguiente código para “hola.c”: #include <stdio.h>
int main()
{
printf("Hola!!!\n");
}
Ejecución $ cd $IDIR
$ bin/sslittle-na-sstrix-gcc -o test dev/test.c
$ simplesim-3.0/sim-outorder test > output.txt
$ gedit output.txt
El fichero debe contener: Hola!!! •
Simulador sim­outorder Los argumentos aceptados por sim‐outorder son los mostrados en la figura 111: # -option
-config
-dumpconfig
-h
-v
-d
-i
-seed
<args>
<string>
<string>
<true|false>
<true|false>
<true|false>
<true|false>
<int>
#
#
#
#
#
#
#
#
-q
-chkpt
-redir:sim
<true|false>
<string>
<string>
# false
# <null>
# <null>
#
#
#
-redir:prog
-nice
-max:inst
-fastfwd
-ptrace
<string>
<int>
<uint>
<int>
<string list>
#
#
#
#
#
#
#
#
#
#
-fetch:ifqsize <int>
-fetch:mplat <int>
-fetch:speed <int>
<default>
<null>
<null>
false
false
false
false
1
<null>
0
0
0
<null>
# 4
# 3
# 1
#
#
#
#
#
#
#
#
#
#
#
description
load configuration from a file
dump configuration to a file
print help message
verbose operation
enable debug message
start in Dlite debugger
random number generator seed (0 for timer
seed)
initialize and terminate immediately
restore EIO trace execution from <fname>
redirect simulator output to file (noninteractive only)
redirect simulated program output to file
simulator scheduling priority
maximum number of inst's to execute
number of insts skipped before timing starts
generate pipetrace, i.e.,
<fname|stdout|stderr> <range>
instruction fetch queue size (in insts)
extra branch mis-prediction latency
speed of front-end of machine relative to
182
PFC: Análisis TLB – Mónica Larruy Carrete execution core
# branch predictor type
{nottaken|taken|perfect|bimod|2lev|comb}
2048
# bimodal predictor config (<table size>)
1 1024 8 0
# 2-level predictor config
(<l1size><l2size><hist_size><xor>)
1024
# combining predictor config
(<meta_table_size>)
8
# return address stack size (0 for no return
stack)
512 4
# BTB config (<num_sets> <associativity>)
<null>
# speculative predictors update in {ID|WB}
(default non-spec)
4
# instruction decode B/W (insts/cycle)
4
# instruction issue B/W (insts/cycle)
false
# run pipeline with in-order issue
true
# issue instructions down wrong execution paths
4
# instruction commit B/W (insts/cycle)
16
# register update unit (RUU) size
8
# load/store queue (LSQ) size
dl1:128:32:4:l # l1 data cache config, i.e.,
-bpred
<string>
# bimod
-bpred:bimod
-bpred:2lev
<int>
<int list>
#
#
-bpred:comb
<int>
#
-bpred:ras
<int>
#
-bpred:btb
<int list>
-bpred:spec_update <string>
#
#
-decode:width <int>
-issue:width
<int>
-issue:inorder <true|false>
-issue:wrongpath <true|false>
-commit:width <int>
-ruu:size
<int>
-lsq:size
<int>
-cache:dl1
<string>
{<config>|none}
-cache:dl1lat <int>
-cache:dl2
<string>
#
#
#
#
#
#
#
#
# 1
# l1 data cache hit latency (in cycles)
# ul2:1024:64:4:l # l2 data cache config, i.e.,
{<config>|none}
-cache:dl2lat <int>
# 6
# l2 data cache hit latency (in cycles)
-cache:il1
<string>
# il1:512:32:1:l # l1 inst cache config, i.e.,
{<config>|dl1|dl2|none}
-cache:il1lat <int>
# 1
# l1 instruction cache hit latency (in cycles)
-cache:il2
<string>
# dl2
# l2 instruction cache config, i.e.,
{<config>|dl2|none}
-cache:il2lat <int>
# 6
# l2 instruction cache hit latency (in cycles)
-cache:flush
<true|false>
# false
# flush caches on system calls
-cache:icompress <true|false> # false
# convert 64-bit inst addresses to 32-bit inst
equivalents
-mem:lat
<int list>
# 18 2
# memory access latency (<first_chunk>
<inter_chunk>)
-mem:width
<int>
# 8
# memory access bus width (in bytes)
-tlb:itlb
<string>
# itlb:16:4096:4:l # instruction TLB config, i.e.,
{<config>|none}
-tlb:dtlb
<string>
# dtlb:32:4096:4:l # data TLB config, i.e., {<config>|none}
-tlb:lat
<int>
# 30
# inst/data TLB miss latency (in cycles)
-res:ialu
<int>
# 4
# total number of integer ALU's available
-res:imult
<int>
# 1
# total number of integer multiplier/dividers
available
-res:memport
<int>
# 2
# total number of memory system ports available
(to CPU)
-res:fpalu
<int>
# 4
# total number of floating point ALU's
available
-res:fpmult
<int>
# 1
# total number of floating point
multiplier/dividers available
-pcstat
<string list> # <null>
# profile stat(s) against text addr's (mult
uses ok)
-bugcompat
<true|false>
# false
# operate in backward-compatible bugs mode (for
testing only)
Figura 111: Argumentos del simulador sim‐outorder 183