Upload
lamcong
View
217
Download
1
Embed Size (px)
Citation preview
INGENIERÍA INFORMÁTICA
PROYECTO FINAL DE CARRERA
ANÁLISIS TLB CURSO 20082009
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
3
Í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. Asignación no contigua .................................................................................... 28
3.4.3. 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
PFC: Análisis TLB – Mónica Larruy Carrete
4
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. Técnicas de gestión de memoria .............................................................................. 51
4. TLB (Translation Lookaside Buffer) ........................................................................................... 52
4.1. Introducción ..................................................................................................................... 52
4.1.1. 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
PFC: Análisis TLB – Mónica Larruy Carrete
5
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
PFC: Análisis TLB – Mónica Larruy Carrete
6
Instrucciones Caché .......................................................................................................... 81
Datos Caché ...................................................................................................................... 81
Introducción ..................................................................................................................... 82
TLB .................................................................................................................................... 82
4.12.8.3. AMD K10 Barcelona 65nm................................................................................ 83
4.12.8.4. AMD K10 (AMD Phenom) ................................................................................. 83
5. 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. CACTI ................................................................................................................................ 87
5.2.1. Introducción ............................................................................................................. 87
5.2.2. Funcionamiento ........................................................................................................ 88
6. 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. Estudio del grado de asociatividad ........................................................................... 94
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 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
PFC: Análisis TLB – Mónica Larruy Carrete
7
6.4.2.5. Comparativa: consumo lectura vs consumo escritura ................................... 100
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. Comparativa: consumo lectura vs consumo escritura ................................... 110
7. 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
PFC: Análisis TLB – Mónica Larruy Carrete
8
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
PFC: Análisis TLB – Mónica Larruy Carrete
9
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
PFC: Análisis TLB – Mónica Larruy Carrete
10
Í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
PFC: Análisis TLB – Mónica Larruy Carrete
11
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
PFC: Análisis TLB – Mónica Larruy Carrete
12
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
PFC: Análisis TLB – Mónica Larruy Carrete
13
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
PFC: Análisis TLB – Mónica Larruy Carrete
14
Í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
PFC: Análisis TLB – Mónica Larruy Carrete
15
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
PFC: Análisis TLB – Mónica Larruy Carrete
16
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.
PFC: Análisis TLB – Mónica Larruy Carrete
17
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.
PFC: Análisis TLB – Mónica Larruy Carrete
18
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.
PFC: Análisis TLB – Mónica Larruy Carrete
19
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
PFC: Análisis TLB – Mónica Larruy Carrete
20
é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.
1RISC (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.
PFC: Análisis TLB – Mónica Larruy Carrete
21
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.
2 CISC (Complex Instruction Set Computer) es un modelo de arquitectura de computadores. Los microprocesadores CISC 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.
PFC: Análisis TLB – Mónica Larruy Carrete
22
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,
PFC: Análisis TLB – Mónica Larruy Carrete
23
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.
PFC: Análisis TLB – Mónica Larruy Carrete
24
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
Caché
Memoria principal
Transferencia de palabras
Transferencia de bloques
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
PFC: Análisis TLB – Mónica Larruy Carrete
25
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.
PFC: Análisis TLB – Mónica Larruy Carrete
26
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.
PFC: Análisis TLB – Mónica Larruy Carrete
27
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.
PFC: Análisis TLB – Mónica Larruy Carrete
28
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
PFC: Análisis TLB – Mónica Larruy Carrete
29
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.
PFC:
A continuación, se puede observ
Tanto el espacio lógico como fí
consiste simplemente en encont
Nótese que consecuencia de ell
todas las páginas empiezan en u
página).
Las páginas se transfieren del
marcos. Éstos tienen el mism
almacenamiento real que son m
una nueva página dentro de cua
Resumiendo, mediante la pagin
mismo tamaño. Cada proceso se
necesitarán pocas páginas, mie
introduce un proceso en la mem
su tabla de páginas.
Figura 9: Ejemplo de t
La traducción se lleva a cabo m
proporciona el número de marco
Análisis TLB – Mónica Larruy Carrete
var la forma de una dirección lógica:
Figura 8: Estructura dirección lógica
ísico está dividido en páginas de mismo tamañ
trar la correspondencia entre página y marco.
o es que todas las páginas son del mismo tama
una posición de memoria múltiplo de dicho tam
almacenamiento secundario al primario en b
mo tamaño que las páginas, comienzan en
múltiplos enteros del tamaño fijo de la página y
lquier marco de página o celda de página dispon
nación, la memoria principal se divide en pequ
e divide en páginas del tamaño del marco (los pr
entras que los procesos grandes necesitarán
moria, se cargan todas sus páginas en los marcos
traducción de direcciones mediante paginación
mediante una TP, la cual es indexada por el núm
o.
30
ño y la traducción
ño (2k), y además
maño (frontera de
bloques llamados
direcciones del
y podrá colocarse
ible.
ueños marcos del
rocesos pequeños
más). Cuando se
libres y se rellena
mero de página y
PFC: Análisis TLB – Mónica Larruy Carrete
31
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.
4 MMU: es un dispositivo hardware, responsable del manejo de los accesos a la memoria por parte de la Unidad de 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é.
PFC: Análisis TLB – Mónica Larruy Carrete
32
Computador Tamaño de páginaIBM360/67 4 KBMC68020 256 bytes a 32 KBMIPS R2000/3000 4 KBAlpha 21064 8 KBPentium 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:
Implementación hardware Implementación en memoria principal
Ventaja Se obtiene una alta velocidad en
hardware
La tabla de páginas puede crece según se
quiera
Desventaja Resulta problemática cuando la
tabla de páginas debe ser grande
La velocidad de acceso a memoria es
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.
PFC:
Al igual que en la paginación, un
de segmento y un desplazamient
Con segmentación, un program
estar contiguas.
Si bien la paginación es tran
Generalmente, se asignan los pro
Una consecuencia del tamaño
simple entre las direcciones lógi
segmentación se utilizará una ta
libres en la memoria principal.
Cada entrada de la TS contiene l
entrada también debe proporc
direcciones no válidas. Cuando s
registro especial llamado RIED
permite agilizar el acceso a dicha
Resumiendo, con segmentación
por qué ser del mismo tamaño.
sus segmentos en regiones de m
3.4.4.1. Traducción de di
Figura 10:
Una dirección lógica consta de d
de ese segmento. El número de s
tiene una base de segmento y un
que estar comprendido entre
Análisis TLB – Mónica Larruy Carrete
na dirección lógica segmentada consta de dos p
to.
a puede ocupar más de una partición y éstas n
nsparente al programador, la segmentación s
ogramas y los datos a diferentes segmentos.
desigual de los segmentos es que no hay una
icas y las direcciones físicas. Análogamente a la
abla de segmentos (TS) para cada proceso y un
la dirección de inicio del segmento en la memor
ionar la longitud del segmento, para asegurar
se pasa a ejecutar un proceso, se carga la direcci
(Registro Identificador del Espacio de Direccion
a dirección.
simple un proceso se divide en varios segment
Cuando un proceso se introduce en la memoria
memoria libres y se rellena la tabla de segmentos.
irecciones segmentadas
Traducción de direcciones mediante segmentación
dos partes: un número de segmento y un despla
segmento se utiliza como un índice en la TS. Cad
n límite/tamaño t. El desplazamiento d de la dire
0 y el límite de segmento. En caso contrario
33
partes, un número
no tienen por qué
suele ser visible.
a correspondencia
paginación, en la
a lista de bloques
ria principal. Dicha
r que no se usen
ón de su TS en un
namiento), el cual
tos que no tienen
a, se cargan todos
.
azamiento dentro
a entrada de la TS
ección lógica tiene
o se produce una
PFC:
excepción al sistema operativ
segmento). Si este desplazamie
tabla deseada en la memoria fí
pares registros base/límite.
La traducción, al igual que en
Comprobaciones que se efectúa
1. ¿Está definido el desc
validado.
2. ¿Está el desplazamie
desplazamiento no váli
3.4.4.2. Protección Una ventaja importante de la se
Puesto que los segmentos repr
entradas en el segmento se utilic
que son instrucciones, mientr
instrucciones son no automodi
definirse como de sólo lectura
asociados a cada entrada en la t
como tentativas de escribir en
ejecución como datos. Situand
automáticamente que toda inde
Así, muchos errores frecuentes
puedan ocasionar un daño serio.
Figu
Análisis TLB – Mónica Larruy Carrete
o (tentativa de direccionamiento lógico más
nto es legal, se añade a la base para producir
ísica. La tabla de segmentos es así esencialmen
n la paginación, se lleva a cabo por hardwa
n:
criptor de segmento? Si no es así, error de acce
ento dentro del segmento? Si no es así, e
ido.
egmentación es la asociación de la protección co
resentan una porción del programa, es probab
cen de la misma manera. De ahí que se tengan a
ras que otros son datos. En una arquitectu
ficables, de modo que los segmentos de instr
o sólo ejecución. El hardware verificará los b
abla de segmentos para impedir accesos ilegales
un segmento de sólo lectura o de utilizar un s
do una tabla en un segmento propio, el ha
exación en la tabla es legal, y no sobrepasa los lím
s en programas serán detectados por hardwa
.
ura 11: Esquema protección en segmentación
34
s allá del fin de
la dirección de la
nte una matriz de
are en la MMU.
eso: segmento no
error de acceso:
on los segmentos.
ble que todas las
lgunos segmentos
ura moderna las
rucciones pueden
bits de protección
s a memoria, tales
segmento de sólo
ardware verificará
mites de la misma.
are antes de que
PFC: Análisis TLB – Mónica Larruy Carrete
35
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.
PFC: Análisis TLB – Mónica Larruy Carrete
36
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.
PFC: Análisis TLB – Mónica Larruy Carrete
37
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
0 0 0 0 0 1 0 1 1 1 0 1 1 1 1 0
0 1 1 1 0 1 1 1 1 0110 0 0 1 0
000101
000110
0110012
0
1
Tabla de páginas
Nº de página Desplazamiento de 10 bits
Dirección lógica de 16 bits
Dirección lógica de 16 bits Figura 14: Ejemplo de traducción de dirección lógica a física mediante paginación
PFC: Análisis TLB – Mónica Larruy Carrete
38
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
Paginación Segmentación
¿Necesita el programador saber si está utilizando esta técnica?
Sí No
¿Cuántos espacios lineales de direcciones existen?
1 Muchos
¿Puede el espacio total de direcciones exceder el tamaño de la memoria física?
Sí Sí
¿Pueden distinguirse los procedimientos y los datos, además de protegerse en forma independiente?
No Sí
¿Pueden adecuarse con facilidad las tablas con tamaños fluctuantes?
No Sí
¿Se facilita el uso de procedimientos compartidos entre los usuarios?
No Sí
PFC: Análisis TLB – Mónica Larruy Carrete
39
Reemplazo de un bloque
Trivial (todos los bloques tienen el mismo tamaño)
Difícil (debe encontrar una parte no utilizada en memoria principal de tamaño variable y contigua)
Uso ineficiente de memoria Fragmentación interna Fragmentación externa Tráfico de disco eficiente Sí (ajusta tamaño de
página para equilibra tiempo de acceso y tiempo de transferencia)
No siempre (pequeños segmentos pueden transferir sólo unos pocos bytes)
¿Para qué se inventó esta técnica? Para obtener un gran espacio lineal de direcciones sin tener que adquirir más memoria física
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.
PFC: Análisis TLB – Mónica Larruy Carrete
40
‐ 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.
PFC: Análisis TLB – Mónica Larruy Carrete
41
‐ 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
PFC: Análisis TLB – Mónica Larruy Carrete
42
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
PFC: Análisis TLB – Mónica Larruy Carrete
43
‐ 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
PFC: Análisis TLB – Mónica Larruy Carrete
44
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.
PFC: Análisis TLB – Mónica Larruy Carrete
45
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.
PFC: Análisis TLB – Mónica Larruy Carrete
46
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.
PFC: Análisis TLB – Mónica Larruy Carrete
47
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
PFC: Análisis TLB – Mónica Larruy Carrete
48
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 Memoria virtual paginada
Segmentación simple Memoria virtual segmentada
La MP (Memoria Principal) está divida en trozos pequeños de tamaño fijos llamados marcos.
La MP está divida en trozos pequeños de tamaño fijos llamados marcos.
La MP no está dividida. La MP no está dividida.
El compilador o el sistema de gestión de memoria dividen los programas en páginas.
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).
El programador indica al compilador los segmentos del programa (es decir, el programador toma la decisión).
Fragmentación interna en los marcos.
Fragmentación interna en los marcos.
No existe fragmentación interna.
No existe fragmentación interna.
No existe fragmentación externa.
No existe fragmentación externa.
Fragmentación externa. 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.
El SO debe tener una TP para cada proceso, indicando en qué marco está cada página.
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 tener una TS para cada proceso, indicando la dirección de carga y la longitud de cada segmento.
El SO debe mantener una lista de marcos libres.
El SO debe mantener una lista de marcos libres.
El SO debe mantener una lista de huecos libres en la MP.
El SO debe mantener una lista de huecos libres en la MP.
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.
El procesador usa el nº de segmento y el desplazamiento para calcular las direcciones absolutas.
El procesador usa el nº de segmento 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.
Todos los segmentos de un proceso tienen que estar en la MP para que el proceso se ejecute, a
No todos los segmentos de un proceso tienen que estar en marcos de la MP para que el proceso se
PFC: Análisis TLB – Mónica Larruy Carrete
49
menos que se use superposición.
Las páginas se pueden leer cuando se necesiten.
menos que se use superposición.
ejecute. Los segmentos se pueden leer cuando se necesiten.
La carga de una página en la MP puede requerir descargar otra en el disco.
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
PFC: Análisis TLB – Mónica Larruy Carrete
50
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.
PFC: Análisis TLB – Mónica Larruy Carrete
51
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 Descripción Ventajas Desventajas
ESQUEMAS DE ASIGNACIÓN CONTIGUA
Partición estática 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.
Sencilla de implementar, poca sobrecarga del SO.
Uso ineficiente de la memoria por culpa de la fragmentación interna (el número de procesos activos es fijo)
Partición dinámica Las particiones se crean dinámicamente, de forma que cada proceso se carga en una partición de su mismo tamaño.
No hay fragmentación interna, uso más eficiente de la memoria principal.
Uso ineficiente del procesador, ya que se usa la compactación para contrarrestar la fragmentación externa.
ESQUEMAS DE ASIGNACIÓN NO
CONTIGUA
Paginación simple 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.
No tiene fragmentación externa.
Hay una pequeña cantidad de fragmentación interna.
Segmentación simple
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 interna.
Mejora la utilización de la memoria y reduce la sobrecarga comparada con la partición dinámica
ESQUEMAS CON MEMORIA VIRTUAL
Memoria virtual paginada
Igual que la paginación simple, 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.
No hay fragmentación externa. Alto grado de multiprogramación. Gran espacio virtual para el proceso.
Sobrecarga por gestión compleja de memoria.
Memoria virtual segmentada
Igual que la segmentación simple, excepto que no es necesario cargar todos los segmentos de un proceso. Los segmentos no residentes que sean necesarios se traerán más tarde, automáticamente.
No hay fragmentación interna. Alto grado de multiprogramación. Gran espacio virtual para el proceso. Soporte de protección y compartición.
Sobrecarga por gestión compleja de memoria.
Tabla 5: Resumen de las técnicas de gestión de memoria
PFC: Análisis TLB – Mónica Larruy Carrete
52
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.
PFC: Análisis TLB – Mónica Larruy Carrete
53
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:
Figura 23: Formato de la etiqueta de la entrada del TLB
D irección virtual Flags(D irty , P rotección, U so) D irección fís ica
PFC: Análisis TLB – Mónica Larruy Carrete
54
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
PFC: Análisis TLB – Mónica Larruy Carrete
55
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.
PFC: Análisis TLB – Mónica Larruy Carrete
56
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
PFC: Análisis TLB – Mónica Larruy Carrete
57
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.
PFC: Análisis TLB – Mónica Larruy Carrete
58
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
PFC: Análisis TLB – Mónica Larruy Carrete
59
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
PFC: Análisis TLB – Mónica Larruy Carrete
60
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
5 Principio de cercanías: las referencias a memoria tienden a agruparse. 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í.
PFC: Análisis TLB – Mónica Larruy Carrete
61
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
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
Valid Virtual page Modified Protection Page frame1 140 1 RW 65 1 30 0 R X 14 1 754 0 RW 50 1 98 1 RW 12 1 23 1 R X 59 1 14 1 RW 21 1 854 0 R X 43
PFC: Análisis TLB – Mónica Larruy Carrete
62
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 Fallo Imposible: no se pueden tener una datos en la caché que no se encuentren en la memoria
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
PFC: Análisis TLB – Mónica Larruy Carrete
63
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.
PFC: Análisis TLB – Mónica Larruy Carrete
64
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. VAX11/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.
Figura 28: TLB del VAX‐11/780
Tamaño de página de 512 bytesEntrada 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
PFC: Análisis TLB – Mónica Larruy Carrete
65
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.
PFC: Análisis TLB – Mónica Larruy Carrete
66
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.
PFC: Análisis TLB – Mónica Larruy Carrete
67
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
PFC: Análisis TLB – Mónica Larruy Carrete
68
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).
PFC: Análisis TLB – Mónica Larruy Carrete
69
Figura 31: Diagrama de bloques del procesador Pentium
PaginaciónSegmentació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.
PFC: Análisis TLB – Mónica Larruy Carrete
70
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.
PFC: Análisis TLB – Mónica Larruy Carrete
71
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.
PFC: Análisis TLB – Mónica Larruy Carrete
72
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 Válido/Inválido 0 Inválido 1 Válido
Tabla 9: Valores de los bits del registro TR6 de Pentium
Bit D ¿Acceso de escritura a la página? 0 No 1 Sí
Bit U Nivel de privilegios para acceder 0 PL=0,1,2,3 1 PL=0
Bit W ¿Permitida escritura? 0 No escrituras, sólo lecturas 1 Permite escrituras
Bit PS Tamaño de página 0 4 KBytes 1 4 MBytes
PFC: Análisis TLB – Mónica Larruy Carrete
73
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).
PFC: Análisis TLB – Mónica Larruy Carrete
74
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.
PFC: Análisis TLB – Mónica Larruy Carrete
75
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 Intel Pentium ProDirecciones virtuales 32 bitsDirecciones físicas 32 bitsTamaño de página 4KB, 4MBOrganización del TLB 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
PFC: Análisis TLB – Mónica Larruy Carrete
76
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.
PFC: Análisis TLB – Mónica Larruy Carrete
77
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.
PFC: Análisis TLB – Mónica Larruy Carrete
78
4.12.7. IBM
4.12.7.1. Power1
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 PowerPC 604Direcciones virtuales 52 bitsDirecciones físicas 32 bitsTamaño de página 4KB, seleccionable y 256 MBOrganización del TLB 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.
PFC: Análisis TLB – Mónica Larruy Carrete
79
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)
PFC: Análisis TLB – Mónica Larruy Carrete
80
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
PFC: Análisis TLB – Mónica Larruy Carrete
81
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.
PFC: Análisis TLB – Mónica Larruy Carrete
82
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.
PFC: Análisis TLB – Mónica Larruy Carrete
83
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.
PFC: Análisis TLB – Mónica Larruy Carrete
84
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.
PFC: Análisis TLB – Mónica Larruy Carrete
85
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).
PFC: Análisis TLB – Mónica Larruy Carrete
86
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).
PFC: Análisis TLB – Mónica Larruy Carrete
87
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.
PFC: Análisis TLB – Mónica Larruy Carrete
88
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.
PFC: Análisis TLB – Mónica Larruy Carrete
89
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.
PFC: Análisis TLB – Mónica Larruy Carrete
90
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.
PFC: Análisis TLB – Mónica Larruy Carrete
91
‐ Á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.
PFC: Análisis TLB – Mónica Larruy Carrete
92
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: data_organizational_parameters_valid y
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
PFC: Análisis TLB – Mónica Larruy Carrete
93
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
PFC: Análisis TLB – Mónica Larruy Carrete
94
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
PFC: Análisis TLB – Mónica Larruy Carrete
95
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.
PFC: Análisis TLB – Mónica Larruy Carrete
96
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.
PFC: Análisis TLB – Mónica Larruy Carrete
97
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.
PFC: Análisis TLB – Mónica Larruy Carrete
98
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.
PFC: Análisis TLB – Mónica Larruy Carrete
99
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.
PFC: Análisis TLB – Mónica Larruy Carrete
100
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.
PFC: Análisis TLB – Mónica Larruy Carrete
101
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.
PFC: Análisis TLB – Mónica Larruy Carrete
102
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.
PFC: Análisis TLB – Mónica Larruy Carrete
103
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.
PFC: Análisis TLB – Mónica Larruy Carrete
104
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
PFC: Análisis TLB – Mónica Larruy Carrete
105
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.
PFC: Análisis TLB – Mónica Larruy Carrete
106
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.
PFC: Análisis TLB – Mónica Larruy Carrete
107
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.
PFC: Análisis TLB – Mónica Larruy Carrete
108
6.4.4.3. Consumo: lectura y escritura
a)
b)
c)
d)
e)
Figura 57: Consumo de lectura y escritura en función del número de puertos a) L=1 E=1 b) L=2 E=1 c) L=2 E=2 d) L=4 E=1 e) L=4 E=4
PFC: Análisis TLB – Mónica Larruy Carrete
109
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.
PFC: Análisis TLB – Mónica Larruy Carrete
110
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.
PFC: Análisis TLB – Mónica Larruy Carrete
111
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.
PFC: Análisis TLB – Mónica Larruy Carrete
112
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
PFC: Análisis TLB – Mónica Larruy Carrete
113
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.
PFC: Análisis TLB – Mónica Larruy Carrete
114
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.
PFC: Análisis TLB – Mónica Larruy Carrete
115
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.
PFC: Análisis TLB – Mónica Larruy Carrete
116
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.
PFC: Análisis TLB – Mónica Larruy Carrete
117
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 Área de aplicaciónbzip Compresióngcc Compilador de lenguaje Cgzip Compresiónmcf Combinatoria
vortex Base de datos orientadas a objetos
vpr 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
PFC: Análisis TLB – Mónica Larruy Carrete
118
Nombre Área de aplicaciónart Reconocimiento de imágenes
/Redes neuronales equake Simulación de propagación de
ondas sísmicas mesa 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.
PFC: Análisis TLB – Mónica Larruy Carrete
119
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
PFC: Análisis TLB – Mónica Larruy Carrete
120
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.
PFC: Análisis TLB – Mónica Larruy Carrete
121
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é.
PFC: Análisis TLB – Mónica Larruy Carrete
122
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");
PFC: Análisis TLB – Mónica Larruy Carrete
123
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 */
PFC: Análisis TLB – Mónica Larruy Carrete
124
/* 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;
}
PFC: Análisis TLB – Mónica Larruy Carrete
125
• 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;
}
PFC: Análisis TLB – Mónica Larruy Carrete
126
• 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",
PFC: Análisis TLB – Mónica Larruy Carrete
127
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
PFC: Análisis TLB – Mónica Larruy Carrete
128
{
/* 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");
PFC: Análisis TLB – Mónica Larruy Carrete
129
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)
PFC: Análisis TLB – Mónica Larruy Carrete
130
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.
PFC: Análisis TLB – Mónica Larruy Carrete
131
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;
}
PFC: Análisis TLB – Mónica Larruy Carrete
132
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 Descripción Valor fetch:ifqsize Tamaño del buffer de búsqueda de instrucciones 4 fetch:mplat Latencia (ciclos) de un error de predicción de salto 3 bpred Especifica el tipo de predictor de saltos bimod bpred:bimod Tamaño del predictor bimodal 2048 bpred:2lev Configuración predictor segundo nivel 1 1024 8 decode:width Ancho de banda del decodificador de instrucciones
(instrucciones/ciclo) 4
issue:width Ancho de banda de instrucciones lanzadas a ejecutar (instrucciones/ciclo)
4
issue:inorder Ejecución de instrucciones en orden false issue:wrongpath Ejecución de instrucciones permitidas que se lanzan después
de un error de predicción o especulativo true
ruu:size Tamaño de la ventana de instrucciones (ROB y RS) 64 lsq:size Capacidad de la cola de instrucciones de memoria (LSQ) 32 cache:dl1 Configuración de la caché de datos de primer nivel
(<nombre>:<#líneas>:<tamañoBloque>:<gradoAsociatividad>:<algoritmoReemplazo>)
dl1:256:32:2:l
cache:dl1lat Latencia de acierto de caché de datos de primer nivel 1 cache:dl2 Configuración de la caché de datos de segundo nivel ul2:1024:64:4:lcache:dl2lat Latencia de acierto de caché de datos de segundo nivel 6 cache:il1 Configuración de la caché de instrucciones de primer nivel il1:512:32:1:lcache:il1lat Latencia de acierto de caché de datos de primer nivel 1 cache:il2 Configuración de la caché de instrucciones de segundo nivel unificadacache:il2lat Latencia de acierto de caché de datos de segundo nivel 6 cache:flush Actualiza todas las cachés con llamadas al sistema false cache:icompress Mapea dirección de 64 bits con su equivalente de 32 false mem:lat Especifica latencia de acceso a memoria 250 2 mem:width Ancho del bus de memoria (en bytes) 8 tlb:itlb Configuración del TLB de instrucciones Modificabletlb:dtlb Configuración del TLB de datos Modificableres:ialu Número de ALUs para enteros 4 res:imult Número de unidades para multiplicar/dividir enteros 1 res:memport Número de puertos de la caché de primer nivel 2 res:fpalu Número de ALUs para punto flotante 4 res:fpmult Número de unidades para multiplicar/dividir punto flotante 1
Tabla 14: Valores comunes empleados para la simulación del TLB con y sin L2
PFC: Análisis TLB – Mónica Larruy Carrete
133
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.
PFC: Análisis TLB – Mónica Larruy Carrete
134
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
PFC: Análisis TLB – Mónica Larruy Carrete
135
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:
Tamaño Total TLB: 384 bytes
Tipo y nivel TLB Configuración Tamaño TLB (bytes) tlb:dtlbl1 dtlbl1:16:4096:1:l 64tlb:dtlbl2 dtlbl2:64:4096:1:l 256tlb:itlbl1 itlbl1:16:4096:1:l 64tlb:itlbl2 dtlbl2 TLB unificada con dtlbl2
Tabla 16: Configuración TLB (L1 y L2) de 384 bytes
Tamaño Total TLB: 768 bytes
Tipo y nivel TLB Configuración Tamaño TLB (bytes) tlb:dtlbl1 dtlbl1:32:4096:1:l 128tlb:dtlbl2 dtlbl2:128:4096:1:l 512tlb:itlbl1 itlbl1:32:4096:1:l 128tlb:itlbl2 Dtlbl2 TLB unificada con dtlbl2
Tabla 17: Configuración TLB (L1 y L2) de 768 bytes
Tamaño Total TLB: 1536 bytes
Tipo y nivel TLB Configuración Tamaño TLB (bytes) tlb:dtlbl1 dtlbl1:64:4096:1:l 256tlb:dtlbl2 dtlbl2:256:4096:1:l 1024tlb:itlbl1 itlbl1:64:4096:1:l 256tlb:itlbl2 dtlbl2 TLB unificada con dtlbl2
Tabla 18: Configuración TLB (L1 y L2) de 1536 bytes
Tamaño Total TLB: 3072 bytes
Tipo y nivel TLB Configuración Tamaño TLB (bytes) tlb:dtlbl1 dtlbl1:128:4096:1:l 512tlb:dtlbl2 dtlbl2:512:4096:1:l 2048tlb:itlbl1 itlbl1:128:4096:1:l 512tlb:itlbl2 dtlbl2 TLB unificada con dtlbl2
Tabla 19: Configuración TLB (L1 y L2) de 3072 bytes
PFC: Análisis TLB – Mónica Larruy Carrete
136
Tamaño Total TLB: 6144 bytes
Tipo y nivel TLB Configuración Tamaño TLB (bytes) tlb:dtlbl1 dtlbl1:512:4096:1:l 32tlb:dtlbl2 dtlbl2:1024:4096:1:l 128tlb:itlbl1 itlbl1:512:4096:1:l 32tlb:itlbl2 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.
PFC: Análisis TLB – Mónica Larruy Carrete
137
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 _ _ _ 1 __ _ 1 _ _ 1
T. acceso TLB L2
_ _ 1 _ _ 1 _ _ 1 _ _ 1 _ _ 2 _
_ _ 1 _ _ 1
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.
PFC: Análisis TLB – Mónica Larruy Carrete
138
7.9.1. bzip
7.9.1.1. IPC
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
Tamañototal TLB (bytes)
IPC sin L2
Tamaño total TLB (bytes)
IPC con L2
128 0.2299 384 0.5301256 0.3781 768 0.7829512 0.554 1536 1.01481024 0.8017 3072 1.14062048 1.0238 6144 1.1725
PFC: Análisis TLB – Mónica Larruy Carrete
139
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.
Tamaño total TLB (bytes)
DTLB L1
ITLB L1
128 0.0628 0 256 0.0368 0 512 0.0228 0 1024 0.0121 0 2048 0.0059 0
Tamaño total TLB (bytes)
TLB L2 DTLB L1 ITLB L1
384 0.3682 0.0619 0 768 0.3333 0.0362 0 1536 0.2625 0.0225 0 3072 0.2311 0.0119 0 6144 0.317 0.0059 0
PFC: Análisis TLB – Mónica Larruy Carrete
140
7.9.1.3. Tiempo de acceso
Figura 69: Comparativa tiempo de acceso SPECINT bzip con y sin TLB L2
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.
Tamaño total TLB (bytes)
T. acceso sin L2 Tamaño total TLB (bytes) T. acceso con L2
128 3.5254 384 = (L2:256 – L1:128) 1.3016 256 2.0623 768 = (L2:512 – L1:256) 0.6898 512 1.276 1536 = (L2:1024 – L1:512) 0.34 1024 0.6742 3072 = (L2: 2048 – L1:1024) 0.1592 2048 0.3301 6144 = (L2: 4096 – L1:2048 ) 0.1064
PFC: Análisis TLB – Mónica Larruy Carrete
141
7.9.2. gcc
7.9.2.1. IPC
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
Tamañototal TLB (bytes)
IPC sin L2
Tamaño total TLB (bytes)
IPC con L2
128 0.1493 384 0.2123256 0.1864 768 0.2437512 0.2234 1536 0.26181024 0.2501 3072 0.29842048 0.2624 6144 0.3004
PFC: Análisis TLB – Mónica Larruy Carrete
142
Figura 71: Miss_rate SPECINT gcc para TLB sólo con L1 Figura 72: Miss_rate SPECINT gcc para TLB con L1 y L2
Tabla 26: Valores miss_rate gcc para TLB sólo con L1 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.
Tamaño total TLB (bytes)
DTLB L1
ITLB L1
128 0.0273 0.0034 256 0.0167 0.0017 512 0.0167 0.0017 1024 0.0104 0.0004 2048 0.0045 0.0001
Tamaño total TLB (bytes)
TLB L2 DTLB L1 ITLB L1
384 0.3986 0.0267 0.0034 768 0.3946 0.0161 0.0017 1536 0.4423 0.0101 0.0004 3072 0.0528 0.0064 0.0002 6144 0.0268 0.0047 0.0001
PFC: Análisis TLB – Mónica Larruy Carrete
143
7.9.2.3. Tiempo de acceso
Figura 74: Comparativa tiempo de acceso SPECINT gcc con y sin TLB L2
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.
Tamaño total TLB (bytes)
T. acceso sin L2 Tamaño total TLB (bytes) T. acceso con L2
128 2.7996 384 = (L2:256 – L1:128) 1.1301 256 1.6556 768 = (L2:512 – L1:256) 0.6549 512 0.9239 1536 = (L2:1024 – L1:512) 0.4088 1024 0.5532 3072 = (L2:2048 – L1:1024) 0.0344 2048 0.3918 6144 = (L2:4096 – L1:2048) 0.0143
PFC: Análisis TLB – Mónica Larruy Carrete
144
7.9.3. gzip
7.9.3.1. IPC
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
Tamañototal TLB (bytes)
IPC sin L2
Tamaño total TLB (bytes)
IPC con L2
128 0.1728 384 0.6408256 0.3579 768 1.7432512 0.6742 1536 1.74461024 1.7448 3072 1.74542048 1.7453 6144 1.7455
PFC: Análisis TLB – Mónica Larruy Carrete
145
Figura 76: Miss_rate SPECINT gzip para TLB sólo con L1 Figura 77: Miss_rate SPECINT gzip para TLB con L1 y L2
Tabla 30: Valores miss_rate gzip para TLB sólo con L1 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.
Tamaño total TLB (bytes)
DTLB L1
ITLB L1
128 0.0652 0.0059 256 0.0333 0 512 0.0121 0 1024 0 0 2048 0 0
Tamañototal TLB (bytes)
TLB L2 DTLB L1 ITLB L1
384 0.1403 0.0688 0.0056 768 0.0009 0.0341 0 1536 0.0022 0.0116 0 3072 0.5706 0 0 6144 0.175 0 0
PFC: Análisis TLB – Mónica Larruy Carrete
146
7.9.3.3. Tiempo de acceso
Figura 79: Comparativa tiempo de acceso SPECINT gzip con y sin TLB L2
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.
Tamaño total TLB (bytes)
T. acceso sin L2 Tamaño total TLB (bytes) T. acceso con L2
128 4.436 384 = (L2:256 – L1:128) 0.6749 256 1.654 768 = (L2:512 – L1:256) 0.01498 512 0.6044 1536 = (L2:1024 – L1:512) 0.0059 1024 0.0014 3072 = (L2:2048 – L1:1024) 0.0008 2048 0.0012 6144 = (L2: 4096 – L1:2048 ) 0.0002
PFC: Análisis TLB – Mónica Larruy Carrete
147
7.9.4. mcf
7.9.4.1. IPC
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
Tamaño total TLB (bytes)
IPC sin L2
Tamaño total TLB (bytes)
IPC con L2
128 0.1003 384 0.1217256 0.1146 768 0.1306512 0.1263 1536 0.13621024 0.133 3072 0.14282048 0.1369 6144 0.1472
PFC: Análisis TLB – Mónica Larruy Carrete
148
Tabla 34: Valores miss_rate mcf para TLB sólo con L1 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.
Tamaño total TLB (bytes)
DTLB L1
ITLB L1
128 0.1088 0.0001 256 0.0886 0 512 0.073 0 1024 0.0621 0 2048 0.0524 0
Tamaño total TLB (bytes)
TLB L2 DTLB L1 ITLB L1
384 0.6672 0.1091 0.0001 768 0.6984 0.0889 0 1536 0.7161 0.0731 0 3072 0.488 0.0623 0 6144 0.261 0.0526 0
PFC: Análisis TLB – Mónica Larruy Carrete
149
7.9.4.3. Tiempo de acceso
Figura 84: Comparativa tiempo de acceso SPECINT mcf con y sin TLB L2
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.
Tamaño total TLB (bytes)
T. acceso sin L2 Tamaño total TLB (bytes) T. acceso con L2
128 4.4033 384 = (L2:256 – L1:128) 3.6536 256 4.377 768 = (L2:512 – L1:256) 3.1188 512 3.6232 1536 = (L2:1024 – L1:512) 2.6355 1024 3.0878 3072 = (L2:2048 – L1:1024) 1.5428 2048 2.6079 6144 = (L2:4096 – L1:2048 ) 0.7086
PFC: Análisis TLB – Mónica Larruy Carrete
150
7.9.5. vortex
7.9.5.1. IPC
Figura 85: Comparativa IPC SPECINT vortex con y sin TLB L2 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
Tamañototal TLB (bytes)
IPC sin L2
Tamaño total TLB (bytes)
IPC con L2
128 0.0946 384 0.2177256 0.2059 768 0.325512 0.2882 1536 0.44491024 0.4025 3072 0.51842048 0.4696 6144 0.5757
PFC: Análisis TLB – Mónica Larruy Carrete
151
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.
Tamaño total TLB (bytes)
DTLB L1
ITLB L1
128 0.0775 0.0103 256 0.0238 0.006 512 0.0149 0.0029 1024 0.0095 0.0007 2048 0.0064 0
Tamaño total TLB (bytes)
TLB L2 DTLB L1 ITLB L1
384 0.3271 0.0795 0.0102 768 0.4639 0.0239 0.006 1536 0.3696 0.015 0.0029 3072 0.3678 0.0096 0.0007 6144 0.2542 0.0064 0
PFC: Análisis TLB – Mónica Larruy Carrete
152
7.9.5.3. Tiempo de acceso
Figura 89: Comparativa tiempo de acceso SPECINT vortex con y sin TLB L2
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.
Tamaño total TLB (bytes)
T. acceso sin L2 Tamaño total TLB (bytes) T. acceso con L2
128 7.9777 384 = (L2:256 – L1:128) 2.727 256 2.9423 768 = (L2:512 – L1:256) 1.3879 512 1.6956 1536 = (L2:1024 – L1:512) 0.6442 1024 0.8847 3072 = (L2:2048 – L1:1024) 0.3337 2048 0.5191 6144 = (L2:4096 – L1:2048 ) 0.1368
PFC: Análisis TLB – Mónica Larruy Carrete
153
7.9.6. vpr
7.9.6.1. IPC
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
Tamaño total TLB (bytes)
IPC sin L2
Tamaño total TLB (bytes)
IPC con L2
128 0.1229 384 0.282256 0.222 768 0.3621512 0.3051 1536 0.44391024 0.3699 3072 0.46352048 0.4453 6144 0.5068
PFC: Análisis TLB – Mónica Larruy Carrete
154
Tabla 42: Valores miss_rate vpr para TLB sólo con L1 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.
Tamaño total TLB (bytes)
DTLB L1
ITLB L1
128 0.1245 0.002 256 0.0658 0 512 0.0397 0 1024 0.0264 0 2048 0.0098 0
Tamaño total TLB (bytes)
TLB L2 DTLB L1 ITLB L1
384 0.3123 0.1246 0.0021 768 0.398 0.0661 0 1536 0.2477 0.0395 0 3072 0.1969 0.0262 0 6144 0.0097 0.0001 0
PFC: Análisis TLB – Mónica Larruy Carrete
155
7.9.6.3. Tiempo de acceso
Figura 94: Comparativa tiempo de acceso SPECINT vpr con y sin TLB L2
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.
Tamaño total TLB (bytes)
T. acceso sin L2 Tamaño total TLB (bytes) T. acceso con L2
128 15.8167 384 = (L2:256 – L1:128) 2.1172 256 8.2281 768 = (L2:512 – L1:256) 1.223 512 4.9584 1536 = (L2:1024 – L1:512) 0.5015 1024 3.2979 3072 = (L2: 2048 – L1:1024) 0.2664 2048 1.2251 6144 = (L2: 4096 – L1:2048 ) 0.0039
PFC: Análisis TLB – Mónica Larruy Carrete
156
7.9.7. art
7.9.7.1. IPC
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
Tamaño total TLB (bytes)
IPC sin L2
Tamaño total TLB (bytes)
IPC con L2
128 0.1042 384 0.1624256 0.1366 768 0.1837512 0.1623 1536 0.19521024 0.1838 3072 0.19822048 0.1952 6144 0.2004
PFC: Análisis TLB – Mónica Larruy Carrete
157
Tabla 46: Valores miss_rate art para TLB sólo con L1 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.
Tamaño total TLB (bytes)
DTLB L1
ITLB L1
128 0.0482 0.002 256 0.0825 0 512 0.0304 0 1024 0.0196 0 2048 0.0144 0
Tamañototal TLB (bytes)
TLB L2 DTLB L1 ITLB L1
384 0.3949 0.0769 0 768 0.4295 0.0456 0 1536 0.4954 0.0292 0 3072 0.5012 0.0191 0 6144 0.007 0.0014 0
PFC: Análisis TLB – Mónica Larruy Carrete
158
7.9.7.3. Tiempo de acceso
Figura 99: Comparativa tiempo de acceso SPECFP art con y sin TLB L2
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.
Tamaño total TLB (bytes)
T. acceso sin L2 Tamaño total TLB (bytes) T. acceso con L2
128 10.3164 384 = (L2:256 – L1:128) 1.8574 256 6.0259 768 = (L2:512 – L1:256) 1.1971 512 3.806 1536 = (L2:1024 – L1:512) 0.8803 1024 2.448 3072 = (L2: 2048 – L1:1024) 0.5823 2048 1.8054 6144 = (L2:4096 – L1:2048 ) 0.0126
PFC: Análisis TLB – Mónica Larruy Carrete
159
7.9.8. equake
7.9.8.1. IPC
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
Tamaño total TLB (bytes)
IPC sin L2
Tamaño total TLB (bytes)
IPC con L2
128 0.1629 384 0.4003256 0.3101 768 0.6632512 0.4089 1536 0.81551024 0.6628 3072 0.94192048 0.8147 6144 1.0209
PFC: Análisis TLB – Mónica Larruy Carrete
160
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.
Tamaño total TLB (bytes)
DTLB L1
ITLB L1
128 0.074 0.0007 256 0.0363 0 512 0.0239 0 1024 0.0091 0 2048 0.0047 0
Tamaño total TLB (bytes)
TLB L2 DTLB L1 ITLB L1
384 0.3048 0.0756 0.0007 768 0.2426 0.0368 0 1536 0.1935 0.024 0 3072 0.2466 0.0092 0 6144 0.2407 0.0048 0
PFC: Análisis TLB – Mónica Larruy Carrete
161
7.9.8.3. Tiempo de acceso
Figura 104: Comparativa tiempo de acceso SPECFP equake con y sin TLB L2
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.
Tamaño total TLB (bytes)
T. acceso sin L2 Tamaño total TLB (bytes) T. acceso con L2
128 9.3358 384 = (L2:256 – L1:128) 1.343 256 4.5409 768 = (L2:512 – L1:256) 0.5046 512 2.9856 1536 = (L2:1024 – L1:512) 0.2635 1024 1.1416 3072 = (L2: 2048 – L1:1024) 0.1275 2048 0.5911 6144 = (L2: 4096 – L1:2048 ) 0.0648
PFC: Análisis TLB – Mónica Larruy Carrete
162
7.9.9. mesa
7.9.9.1. IPC
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
Tamaño total TLB (bytes)
IPC sin L2
Tamaño total TLB (bytes)
IPC con L2
128 0.159 384 0.5889256 0.4243 768 1.0188512 0.7189 1536 1.07911024 1.0277 3072 1.10982048 1.0823 6144 1.1149
PFC: Análisis TLB – Mónica Larruy Carrete
163
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.
Tamaño total TLB (bytes)
DTLB L1
ITLB L1
128 0.0751 0.0029 256 0.0277 0 512 0.0096 0 1024 0.0022 0 2048 0.0015 0
Tamañototal TLB (bytes)
TLB L2 DTLB L1 ITLB L1
384 0.1563 0.0778 0.0029 768 0.079 0.0278 0 1536 0.1529 0.0096 0 3072 0.4268 0.0021 0 6144 0.5734 0.0014 0
PFC: Análisis TLB – Mónica Larruy Carrete
164
7.9.9.3. Tiempo de acceso
Figura 109: Comparativa tiempo de acceso SPECFP mesa con y sin TLB L2
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.
Tamaño total TLB (bytes)
T. acceso sin L2 Tamaño total TLB (bytes) T. acceso con L2
128 9.7493 384 = (L2:256 – L1:128) 0.9177 256 3.4598 768 = (L2:512 – L1:256) 0.1567 512 1.1949 1536 = (L2:1024 – L1:512) 0.0999 1024 0.2728 3072 = (L2:2048 – L1:1024) 0.0606 2048 0.1831 6144 = (L2:4096 – L1:2048) 0.0548
PFC: Análisis TLB – Mónica Larruy Carrete
165
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.
PFC: Análisis TLB – Mónica Larruy Carrete
166
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
PFC: Análisis TLB – Mónica Larruy Carrete
167
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).
PFC: Análisis TLB – Mónica Larruy Carrete
168
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.
PFC: Análisis TLB – Mónica Larruy Carrete
169
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.
PFC: Análisis TLB – Mónica Larruy Carrete
170
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.
PFC: Análisis TLB – Mónica Larruy Carrete
171
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
PFC: Análisis TLB – Mónica Larruy Carrete
172
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.
PFC: Análisis TLB – Mónica Larruy Carrete
173
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”
PFC: Análisis TLB – Mónica Larruy Carrete
174
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
PFC: Análisis TLB – Mónica Larruy Carrete
175
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
PFC: Análisis TLB – Mónica Larruy Carrete
176
• 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.
‐ http://www.studiokhalid.com/simplescalar/simplescalar.htm
PFC: Análisis TLB – Mónica Larruy Carrete
177
‐ 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.
PFC: Análisis TLB – Mónica Larruy Carrete
178
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
PFC: Análisis TLB – Mónica Larruy Carrete
179
$ 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)"
PFC: Análisis TLB – Mónica Larruy Carrete
180
$ 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-na-sstrix/bin
$ ./configure --host=$HOST --target=$TARGET --with-gnu-as --with-gnu-ld --prefix=$IDIR
$ make LANGUAGES=”C” CFLAGS=”-g -03” CC=”gcc”
PFC: Análisis TLB – Mónica Larruy Carrete
181
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-na-
sstrix/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:
PFC: Análisis TLB – Mónica Larruy Carrete
182
#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 simoutorder
Los argumentos aceptados por sim‐outorder son los mostrados en la figura 111:
# -option <args> # <default> # description -config <string> # <null> # load configuration from a file -dumpconfig <string> # <null> # dump configuration to a file -h <true|false> # false # print help message -v <true|false> # false # verbose operation -d <true|false> # false # enable debug message -i <true|false> # false # start in Dlite debugger -seed <int> # 1 # random number generator seed (0 for timer seed) -q <true|false> # false # initialize and terminate immediately -chkpt <string> # <null> # restore EIO trace execution from <fname> -redir:sim <string> # <null> # redirect simulator output to file (non- interactive only) -redir:prog <string> # <null> # redirect simulated program output to file -nice <int> # 0 # simulator scheduling priority -max:inst <uint> # 0 # maximum number of inst's to execute -fastfwd <int> # 0 # number of insts skipped before timing starts -ptrace <string list> # <null> # generate pipetrace, i.e., <fname|stdout|stderr> <range> -fetch:ifqsize <int> # 4 # instruction fetch queue size (in insts) -fetch:mplat <int> # 3 # extra branch mis-prediction latency -fetch:speed <int> # 1 # speed of front-end of machine relative to
PFC: Análisis TLB – Mónica Larruy Carrete
183
execution core -bpred <string> # bimod # branch predictor type {nottaken|taken|perfect|bimod|2lev|comb} -bpred:bimod <int> # 2048 # bimodal predictor config (<table size>) -bpred:2lev <int list> # 1 1024 8 0 # 2-level predictor config (<l1size><l2size><hist_size><xor>)
-bpred:comb <int> # 1024 # combining predictor config (<meta_table_size>) -bpred:ras <int> # 8 # return address stack size (0 for no return stack) -bpred:btb <int list> # 512 4 # BTB config (<num_sets> <associativity>) -bpred:spec_update <string> # <null> # speculative predictors update in {ID|WB} (default non-spec) -decode:width <int> # 4 # instruction decode B/W (insts/cycle) -issue:width <int> # 4 # instruction issue B/W (insts/cycle) -issue:inorder <true|false> # false # run pipeline with in-order issue -issue:wrongpath <true|false> # true # issue instructions down wrong execution paths -commit:width <int> # 4 # instruction commit B/W (insts/cycle) -ruu:size <int> # 16 # register update unit (RUU) size -lsq:size <int> # 8 # load/store queue (LSQ) size -cache:dl1 <string> # dl1:128:32:4:l # l1 data cache config, i.e., {<config>|none} -cache:dl1lat <int> # 1 # l1 data cache hit latency (in cycles) -cache:dl2 <string> # 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