ingenierÍa informÁtica proyecto final de …deim.urv.cat/~pfc/docs/pfc830/d1245741498.pdf ·...

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


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


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


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


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.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


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


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


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


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


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


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


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


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 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


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


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.


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.


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.


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


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.


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.


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,


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.


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


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.


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.


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.


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


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


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é.


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


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


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


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.


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.


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


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í


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.


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.


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


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


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


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.


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.


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.


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


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


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


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.


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


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.


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


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


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.


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


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.


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


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


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í.


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


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


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.


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


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.


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.


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


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).


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.


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.


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.


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


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).


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.


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


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.


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.


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.


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)


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


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.


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.


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.


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.


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).


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).


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.


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.


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.


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.


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.


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


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


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


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.


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.


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.


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.


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.


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.


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.


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.


102


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.


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.


104


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


105


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.


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.


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.


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


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.


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.


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.


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.


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


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.


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.


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.


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.


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


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.


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


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.


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é.


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");


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 */


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.


tlb_dl2_access_fn(enum mem_cmd cmd, /* access cmd, Read or Write */





{

if (cmd == Read)


else

/* FIXME: unlimited write buffers */

return 0;

}


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 */


tlb_il1_access_fn(enum mem_cmd cmd, /* access cmd, Read or Write */





{

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{


panic("writes to instruction not supported");

}

}

else return tlb_miss_lat_L1;

}


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 */


tlb_il2_access_fn(enum mem_cmd cmd, /* access cmd, Read or Write */





{

/* this is a miss to the lowest level */

if (cmd == Read)


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",


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",


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


128

{

/* Wrong parameters => Error */

/* Correct parameters => creation D-TLB L1 */

if (sscanf(tlb_dl1_opt, "%[^:]:%d:%d:%d:%c",


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",


fatal("bad l2 D-TLB parms:


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");


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*/


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*/


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)


130

fatal("bad l1 I-TLB parms:


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",


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.


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;

}


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


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.


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


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


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









136




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.


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.


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


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.


DTLB L1

ITLB L1

128 0.0628 0 256 0.0368 0 512 0.0228 0 1024 0.0121 0 2048 0.0059 0


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


140


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.


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


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


IPC sin L2


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


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.


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



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


143


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.



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


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


IPC sin L2


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


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.


DTLB L1

ITLB L1

128 0.0652 0.0059 256 0.0333 0 512 0.0121 0 1024 0 0 2048 0 0



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


146


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.



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


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


IPC sin L2


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


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.


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



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


149


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.



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


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


IPC sin L2


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


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.


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



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


152


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.



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


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


IPC sin L2


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


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.


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



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


155


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.



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


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


IPC sin L2


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


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.


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



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


158


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.



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


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


IPC sin L2


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


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.


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



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


161


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.



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


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


IPC sin L2


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


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.


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



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


164


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.



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


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.


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


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).


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.


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}


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.


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.


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}


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.


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.


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}


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.


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


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.


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”


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


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


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.

pdf

‐ http://www.studiokhalid.com/simplescalar/simplescalar.htm


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.


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


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)"


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”


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




¿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:


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


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

ingenierÍa informÁtica proyecto final de …deim.urv.cat/~pfc/docs/pfc830/d1245741498.pdf ·...

Documents