INSTITUTO POLITÉCNICO NACIONAL

CENTRO DE INVESTIGACIÓN EN COMPUTACIÓN

“OPTIMIZACIÓN DEL BANCO DE REGISTROS EN PROCESADORES FUERA DE ORDEN ESPECULATIVOS”

T

E S I

S

QUE PARA OBTENER EL GRADO DE: MAESTRO EN CIENCIAS EN INGENIERÍA DE CÓMPUTO CON ESPECIALIDAD EN SISTEMAS DIGITALES

PRESENTA:

Ing. MOISÉS ARTURO ZÁRATE SEGURA DIRECTOR DE TESIS: DR. LUIS ALFONSO VILLA VARGAS DIRECTOR DE TESIS: DR. OSCAR CAMACHO NIETO

México, D. F. a 13 de junio de 2007

Resumen:

Los procesadores superescalares han mejorando con el paso del tiempo, y uno de los puntos más importantes es la optimización del rendimiento. Sin embargo, cada modificación que se añade deriva en el aumento del hardware, lo cual, impacta directamente en el consumo de energía. Hoy en día, la reducción del consumo de potencia es un tema muy importante entre los arquitectos de computadoras, debido al calentamiento que están presentando las arquitecturas actuales.

Uno de los principales consumidores de energía dentro de los procesadores, es el banco de registros, ya que se tienen múltiples accesos de lecturas y escrituras. Los datos contenidos dentro de los registros, están formados por diferentes combinaciones binarias de ceros y unos. Dado que la lectura del dato se realiza bit por bit, se tiene un consumo de energía importante, debido a las activaciones que tienen los circuitos que forman los bit’s. Por lo tanto, en este trabajo se diseñan y evalúan dos técnicas que minimizan el número de accesos de lectura al banco de registros, Detección de Ceros utilizando un bit de Bandera (DCbB) y Detección de Ceros utilizando una Tabla de Mapeo (DCTM). Ambas técnicas se implementaron y evaluaron con el simulador simplescalar V.3.0. y las cargas de trabajo representativas usadas fueron los SPEC95.

La heurística utilizada mostró de primera instancia que el 41% de los registros utilizados en una arquitectura convencional contenían valores iguales a ceros. De esta manera, para la primera técnica se colocó un bit de bandera por cada cadena de word, int, byte y nibble, el cual, se activaría con un uno si la cadena fuera igual a cero o en el caso contrario con un bit igual a cero; Con ello, se tuvo una reducción del 55% de lecturas y del 50% de escrituras, y ambas reducciones se deberían reflejar en un ahorro del consumo de energía, aun cuando, en algunos casos se requiere la lectura del bit de bandera mas la cadena. Para la segunda técnica se descartó el bit de bandera de la primera y se incrementó el hardware fuera de la trayectoria de ejecución, con la finalidad de solamente pasar un bit que le correspondiera a cada cadena de ceros. Con ésta técnica, se logró una reducción del 62% de lecturas y 56% de escrituras de los bits del banco de registros.

Abstract

Through the years the superscales processors have been improving; one of the most important improvements is the optimized performance. However, each modification ends up in a hardware increase that shocks directly with the power consumption. Now a days, the low power is an important subject among the computers engineers, because of the warm up that have been showing the actual architectures. One of the main power consumers in the processors, is the register file, because it ha many reading and writing access. The information contained in this one is formed for different binary combinations of zero and one. The reading of data is made bit by bit´s, process that has a big power consumption, due to the enable circuits that bit´s make. That is why engineers have been working on the design and evaluation of two techniques that minimize the number of reading access to the register file. One of them is the zero detections using a mapping board. Both techniques have been created and proved by the simplescalar simulator V.3.0 and the benchmarks used were the SPEC95. The heuristic showed that 41% of the records used in a conventional architecture had zeros. In this way, for the first technique was used a flag bit for each chain of word, int, byte and nibble, that would be actived by number one if the chain were iqual to zero or in the opposite case a bit iqual to zero. This make possible the reduction of 55% in readings and 50% writings, and both of this reductions should reflect a power consumption save, even if, in some cases is required the reading of the flag bit plus the chain. For the second technique the flag bit of the first one was rule out, and it was increased the hardware out of the execution trajectory in order to passé just one of the zero chain bit´s. whit technique, we got a reduce of 62% in readings and 56% in writings of the register file bit´s.

DEDICATORIA

A mi padre: Por todo su apoyo, confianza, esfuerzo y esmero que deposito en mi. Tú quien siempre has sido mi mejor amigo y guía en esta vida.

AGRADECIMIENTOS

Al Instituto Politécnico Nacional (IPN IPN), IPN , por darme un proyecto de vida profesional y ser mi alma mater. Al Centro de Investigación en Computación (CIC CIC), CIC por darme la oportunidad de probarme a mi mismo la capacidad de ser un investigador. Al Instituto Mexicano del Petróleo (IMP IMP), IMP por apoyarme con una beca para poder culminar este trabajo. Al Dr. Luís Alfonso Villa Vargas, por darme todos los conocimientos para poder realizar este trabajo, el cual me ha forjado como investigador. Al Dr. Oscar Camacho Nieto, por su apoyo para poder realizar este trabajo. A mis sinodales: Dr. Cornelio Yánez Márquez, Dr. Luís Pastor Sánchez Fernández, M. en C. Urbieta Parrazales Romeo y M. en C. Sandoval Reyes Sergio, por sus valiosas observaciones para enriquecer este documento.

ÍNDICE I. Índice de Figuras .................................................................................................iii II. Índice de tablas ....................................................................................................vi III. Índice de gráficas.................................................................................................vii IV. Introducción……………………………………………………………………..x V. Organización del trabajo de tesis………………………………………………..xi VI. Objetivo general………………………………………………………………....xii 1. Fundamentos de los Procesadores………………………………………………1 1.1. Historia de las computadoras. ......................................................................2 1.2. Procesadores Superescalares. .......................................................................3 1.2.1. Microarquitectura de un procesador superescalar .............................3 1.2.2. Camino de Datos (Data Path) ...........................................................4 1.2.2.1.Búsqueda de instrucciones y predicción de saltos.......................4 1.3. Modelos Analíticos del Rendimiento de un Procesador…………………...5 1.3.1. Aproximación Analítica………………………………………….….7

2. Banco de Registros……………………………………………………………...9 2.1. Introducción………………………………………………………………..10 2.2. Banco de Registros………………………………………………………....12 2.3. Estructura de un Banco de Registros………………………………………13 2.3.1. Registros de Lectura y Escritura……………………………………17 2.4. Registros Físicos y Registros Lógicos……………………………………..18

3. Metodología de Evaluación……………………………………………………..20 3.1 Herramientas de Simulación………………………………………………..21 3.1.1. Descripción de simuladores para arquitecturas de procesadores…....21 3.1.2. Selección de la herramienta de simulación………………………....23 3.2 Cargas de trabajo (Benchmarks) …………………………………………...30

4. Disquisición Experimental para la Optimización del Banco de Registros……...32 4.1 Introducción…………………………………………………………...........33 4.2 Trabajos Relacionados……………………………………………………...34 i

4.3 Mayor consumidor de registros………………………………...…………...34 4.4 Conteo de los registros cero y diferentes de cero…………………………...36 4.5 Registros cero totales de lectura y de escritura……………………………..38 4.6 División del Registro en nibble’s, byte’s, int’s y word’s…………………...40

5. Modelos Propuestos para la Optimización del Rendimiento en el Banco de Registros Físicos con un Impacto en el Consumo de Energía…………………..52 5.1 Modelo de Detección de Ceros utilizando un bit de Bandera (DCbB)……..53 5.2 Modelo de Detección de Ceros utilizando una Tabla de Mapeo (DCTM)…61 Conclusiones………………………..……………...………………………………..69 Trabajos Futuros…………………………………………………………………….70 Bibliografía………………………………………………………………………….71 Anexo A….………………………………………………………………………….72 Anexo B….………………………………………………………………………….78

ii

Índice de Figuras Figura 1.1

Etapas de procesamiento de un procesador superescalar ..................3

Figura 1.2

Muestra el tiempo de ejecución .........................................................6

Figura 2.1

Arquitectura PowerPc .......................................................................10

Figura 2.2

Arquitectura Mips R10000 ................................................................10

Figura 2.3

Arquitectura Alpha 21264……………………………………..........11

Figura 2.4

Arquitectura Alpha 21264 .................................................................11

Figura 2.5

Registros de 8 bit’s, 16 bit’s, 32 bit’s y 64 bit’s................................13

Figura 2.6

Estructura interna de un registro a nivel transistor ............................13

Figura 2.7

Circuito de un Inversor ......................................................................14

Figura 2.8

Muestra la relación entre voltajes de entrada y salida, cuando se realiza transición del inversor............................................................15

Figura 2.9

Muestra la configuración interna de un bit.…………………………15

Figura 2.10

Diagrama del bit a nivel transistor, el cual muestra la transición de 1 y 0 ..............................................................................................16

Figura 2.11

Muestra la transición que se realiza dentro del bit ...........................16

Figura 2.12

Muestra como se realiza una lectura y escritura al banco de registros con diferentes operaciones..................................................18

Figura 2.13

Muestra los bancos de registros físicos y lógicos..............................13

Figura 3.1

Diagrama esquemático del simulador “sim-outorder” del Simplescalar ......................................................................................25

Figura 3.2

Bloques de registros enteros y de punto flotante de la arquitectura simulada por “sim-outorder”.........................................27

Figura 3.3

Módulos que conforman el simulador “Sim-Outorder” ....................27

Figura 3.4

Funciones que emulan las etapas del procesador en el simulador Core o Núcleo....................................................................................28

Figura 3.5

Funciones creadas dentro del Simulador ...........................................29

Figura 4.1

Muestra los puntos que aportan registros al procesador....................33

Figura 4.2

Consumo de energía en forma general de los diferentes componentes contenidos dentro del procesador ................................34

iii

Figura 4.3

Porcentajes de consumo de energía en los diferentes módulos de un procesador.....................................................................................35

Figura 4.4

Muestra la representación de los contadores con las flechas A, B y C .....................................................................................................35

Figura 4.5

La figura muestra el contador “A” que se colocó dentro del simulador para contar los registros con valor igual y diferente de cero en las etapas de lectura y escritura al banco de registros físico ..................................................................................................37

Figura 4.6

Muestra los contadores de los registros de lectura y escritura con valor igual y diferente de cero ...........................................................38

Figura 4.7

Representa las cadenas de nibble´s, byte´s, int y word´s, contenidas dentro de un registro de 32 bit´s ......................................40

Figura 4.8

Forma correcta de cómo se obtuvieron las cadenas de enteros con valores iguales a cero dentro de los registros .............................43

Figura 4.9

Forma incorrecta de comprender cómo se obtuvieron las cadenas de enteros con valor igual a cero dentro de los registros...................43

Figura 4.10

Forma correcta de cómo se obtuvieron las cadenas de byte’s con valores iguales a cero dentro de los registros ....................................46

Figura 4.11

Forma incorrecta de comprender cómo se obtuvieron las cadenas de byte’s con valor igual a cero, dentro de los registros....................46

Figura 4.12

Forma correcta de como se obtuvieron las cadenas de nibble’s con valores iguales a cero, dentro de los registros ............................48

Figura 4.13

Forma incorrecta de comprender cómo se obtuvieron las cadenas de nibble’s con valor igual a cero dentro de los registros .................49

Figura 5.1

Muestra la etapa en donde se aumentó un ciclo dentro de la arquitectura convencional de un procesador .....................................53

Figura 5.2

Muestra la técnica DCbB para las cadenas de word, int, byte y nibble .................................................................................................54

Figura 5.3

Muestra la representación esquemática de la división en palabras (word’s), con su bit de bandera. ........................................................55

Figura 5.4

Muestra la división en int de un registro, con su bit de bandera .......56

iv

Figura 5.5

Muestra la división en byte’s de un registro, con su bit de bandera...............................................................................................57

Figura 5.6

Muestra la división en nibble’s de un registro, con su bit de bandera...............................................................................................58

Figura 5.7

Muestra la etapa en donde se colocó el detector de ceros .................61

Figura 5.8

Muestra la lectura anticipada de los datos contenidos dentro de los registros, para conocer si sus valores son iguales ó diferentes de ceros ..............................................................................................61

Figura 5.9

Proceso de construcción del dato que se lee del Banco de Registros ............................................................................................61

v

Índice de Tablas Tabla 1.1

Desde 1989 se le da el nombre de familia, a los grupos de procesadores que se mejoran..............................................................3

Tabla 3.1

Simuladores de fácil comprensión .....................................................21

Tabla 3.2

Simuladores de complejidad media ...................................................22

Tabla 3.3

Simuladores de gran complejidad. .....................................................23

Tabla 3.4

Conjunto de simuladores de Simplescalar …………...………...…..25

Tabla 3.5

Cargas de trabajo de tipo entero (SPEC95INT).................................30

Tabla 3.6

Cargas de trabajo de tipo punto flotante (SPEC95FP).......................30

vi

Índice de Gráficas Gráfica 4.1

Porcentaje de registros usados en las etapas de WB, BRF y BRL. ...36

Gráfica 4.2

Muestra la utilidad de registros con valor igual a cero por SPEC y su promedio general........................................................................37

Gráfica 4.3

Porcentajes de registros con valor igual a cero que se tiene cuando se realiza una lectura por SPEC, y su promedio general ......39

Gráfica 4.4

Porcentajes de registros con valor igual a cero que se tiene cuando se realiza una escritura por SPEC y su promedio general.....39

Gráfica 4.5

Porcentaje del uso de las cadenas de word con valor igual a cero y diferente de cero, que se detectaron dentro de los registros usados por la arquitectura ..................................................................41

Gráfica 4.6

Porcentaje de cadenas de word con valor igual a cero y diferente de cero cuando se tiene un acceso de lectura.....................................41

Gráfica 4.7

Porcentaje de cadenas de word con valor igual a cero y diferente de cero, cuando se tiene un acceso de escritura.................................42

Gráfica 4.8

Porcentaje del uso de las cadenas de enteros (int) con valor igual a cero .................................................................................................44

Gráfica 4.9

Porcentaje del uso de las cadenas de enteros con valor igual a cero y diferente de cero cuando se tiene un acceso de lectura ..........44

Gráfica 4.10

Porcentaje del uso de las cadenas de enteros con valor igual a cero y diferente de cero cuando se tiene un acceso de escritura........45

Gráfica 4.11

Porcentaje de byte´s ceros totales y su promedio .............................47

Gráfica 4.12

Porcentaje de byte´s ceros y diferentes de ceros de lecturas, y su promedio............................................................................................47

Gráfica 4.13

Porcentaje de byte´s ceros y diferentes de ceros de escritura y su promedio............................................................................................48

Gráfica 4.14

Porcentaje de nibble’s ceros y diferentes de ceros totales y su promedio............................................................................................49

Gráfica 4.15

Porcentaje de nibble´s ceros y diferentes de ceros de lecturas y su promedio .......................................................................................50

vii

Gráfica 4.16

Porcentaje de nibble´s ceros y diferentes de ceros de escrituras y su promedio .......................................................................................50

Gráfica 4.17

Resumen de los porcentajes de las cadenas iguales a cero para los accesos de lectura y escritura, al banco de registros....................51

Gráfica 5.1

Porcentajes de la reducción de cadenas word’s para el caso de lecturas y escrituras con la técnica del bit de bandera (DCbB) .........55

Gráfica 5.2

Porcentajes de cadenas de int’s para el caso de lecturas y escrituras con el bit de bandera y su promedio..................................56

Gráfica 5.3

Porcentajes de byte’s de lecturas y escrituras con el bit de bandera y su promedio.......................................................................57

Gráfica 5.4

Porcentajes de nibble´s de lecturas y escrituras con el bit de bandera y su promedio.......................................................................58

Gráfica 5.5

Comparación entre los promedios de las distintas granularidades analizadas nibble’s, byte’s, int’s y word’s en lecturas y escrituras............................................................................................59

Gráfica 5.6

Muestra la diferencia en porcentajes de lecturas y escrituras iguales a ceros....................................................................................60

Gráfica 5.7

Muestra el porcentaje en comparación del ciclo que se adicionó para poder realizar la técnica DCbB, con respecto a los ciclos originales que contiene una arquitectura sin modificar. ....................60

Gráfica 5.8

Gráfica que muestra la optimización que se tuvo con la técnica DCTM para las cadenas de word’s que leen y se escriben................63

Gráfica 5.9

Gráfica que muestra la optimización en el ahorro de energía para cadenas de int’s, en lecturas y escrituras ...........................................65

Gráfica 5.10

Gráfica que muestra la optimización en el ahorro de energía para cadenas de byte’s, en lecturas y escrituras.........................................66

Gráfica 5.11

Gráfica que muestra la optimización en el ahorro de energía para cadenas de nibble’s, en lecturas y escrituras .....................................67

Gráfica 5.12

Gráfica que muestra la optimización para las cadenas de word’s, int’s, byte’s y nibble’s con la segunda técnica...................................68

viii

Gráfica 5.13

Gráfica que muestra la optimización de la técnica DCbB V.S. la técnica DCTM ...................................................................................68

ix

Introducción Situándonos en la forma en que se ejecutan las instrucciones en los procesadores superescalares, después de decodificar las instrucciones se conocen los registros involucrados (fuentes y destinos), con lo que posteriormente se accede al banco de registros de la arquitectura. Esta actividad genera un cuello de botella en la ejecución de las instrucciones, dado que este proceso se realiza para cada instrucción; al tener millones de instrucciones en cada programa que se ejecuta, es necesario implementar mecanismos que optimicen el acceso a los registros de la arquitectura, por lo tanto, se han creado diferentes técnicas para mejorar el rendimiento, mismas que han incrementando el hardware, pero a causa de esto, también se presenta un mayor consumo de energía, el cual, se ha tratado de ir disminuyendo sin afectar al rendimiento[15]. Una de las técnicas más importantes es la reducción de energía al tener un bit de línea[16]. Otros han propuesto las técnicas con múltiples sub-bancos, a los que se accede cada vez que se tiene un bit de línea activo por cada uno de ellos [12]. Otras técnicas tuvieron un poco mas de trascendencia como es la detección de registros zero [10, 11, 16], la cual consiste en detectar solo registros que contiene valores cero dentro de las operaciones que se realizan en las unidades funcionales. También, es importante mencionar que otros han propuesto la implementación de técnicas que reducen los múltiples accesos que se tienen al hacer una lectura y escritura al banco de registros[2], logrando con ello la reducción de consumo de energía y en algunos casos, el incremento en el rendimiento. Las técnicas de detección de ceros en arquitecturas superescalares, son muy importantes en la actualidad, ya que gracias a ellas se han tenido buenos resultados para la reducción de energía dentro de los procesadores superescalares[16], y estas técnicas son susceptibles de continuar mejorándose.

x

Organización del Trabajo de Tesis El trabajo esta organizado de la siguiente forma: en el capitulo 1, se plantea el estado del arte, haciendo una breve descripción histórica de la evolución de las arquitecturas de computadoras, posteriormente se hace énfasis en la forma de trabajo de los procesadores superescalares y finalmente se especifican las características del banco de registros, también, se presentan algunos modelos analíticos existentes y se hacen referencias a otros modelos analíticos existentes; con ellos se pretende justificar la razón por la que el presente trabajo se fundamenta en los modelos analíticos conocidos, para complementar la evaluación con herramientas de simulación que finalmente derivan en un modelo experimental eficiente. En el capitulo 2 se hace una descripción de la forma de trabajo del banco de registros y los tipos de registros, con la finalidad de dar a conocer como se produce el consumo de energía de los bit`s, a nivel transistor, que están contenidos dentro de los registros. En el capitulo 3, se hace una descripción de la metodología de evaluación utilizada haciendo énfasis en el simulador utilizado, así como las cargas de trabajo representativas usadas para la evaluación y validación de este trabajo. En el capitulo 4, se realizan las disquisiciones experimentales que justifican la motivación del trabajo realizado, encontrándose, entre otras cosas, que existe un alto porcentaje de registros con valor de ceros cuando se tienen accesos de lecturas y escrituras, así como cadenas de ceros con tamaño de nibble, byte, int y word. En el capitulo 5, se diseñan, simulan y evalúan los modelos de Detección de Ceros utilizando un bit de Bandera (DCbB) y Detección de Ceros utilizando una Tabla de Mapeo (DCTM); presentando las gráficas de resultados en relación al rendimiento. Por último, se presentan las conclusiones de este trabajo y propuestas para trabajos futuros, junto con una lista de las referencias contenidas en el desarrollo de este trabajo. En la siguiente sección se presenta el objetivo general y los objetivos específicos, que se persiguen en este trabajo.

xi

Objetivo General Optimizar el banco de registros con dos modelos que detectan ceros, en donde el primero cuenta con un bit de bandera, llamado: Detección de Ceros utilizando un bit de Bandera (DCbB) y el segundo consta de una tabla de mapeo en la que se indica el contenido de los registros, llamado: Detección de Ceros utilizando una Tabla de Mapeo (DCTM). Objetivos Específicos

•

Configurar el simulador simplescalar con la arquitectura convencional que se pretende evaluar y aplicarle cargas de trabajo representativas para obtener estadísticas de comportamiento de la etapa en donde se accede al banco de registros, principalmente en la etapa de ejecución y postescritura.

•

El estudio y análisis del comportamiento de los accesos de lecturas y escrituras que se hacen al banco de registros, para proponer técnicas que mejoren el rendimiento del banco de registros, que a su vez tengan un impacto en la reducción del ahorro del consumo de energía

•

Diseño de dos nuevas estructuras de banco de registros que mejoren el rendimiento y al mismo tiempo se obtenga un ahorro del consumo de potencia dentro del procesador.

•

Adaptar el simulador simplescalar a la arquitectura que contempla los esquemas propuestos, aplicándolos a las cargas de trabajo representativas, para obtener estadísticas de comportamiento que posteriormente serán comparadas, con el comportamiento de una arquitectura convencional; gráficando el beneficio obtenido en la disminución de los accesos de lecturas y escrituras que se hacen al banco de registros.

xii

Capítulo 1

Introducción

1 CAPÍTULO

Fundamentos de los Procesadores

Resumen: En este capítulo, se da una cronología sobre la aparición de los primeros diseños de computadoras de propósito general hasta nuestros días, comentando principalmente los cambios tecnológicos que propiciaron la mejora en el rendimiento. Posteriormente, se hace una descripción de la forma de trabajo de las arquitecturas superescalares y finalmente, se describen el análisis realizado a los parámetros que influyen en el rendimiento, así como en el consumo de potencia.

1

Capítulo 1

Introducción

1.1 Historia de las Computadoras La primera computadora electrónica de propósito general, limitada principalmente por una pequeña cantidad de memoria y programación tediosa, fue la ENIAC (Electronic Numerical Integrator and Calculator) desarrollada por J. Presper Eckert y John Mauchly en la Universidad de Pennsylvania, la cual, utilizaba 20 registros de 10 bit’s; usados para realizar operaciones con decimales y operaciones con fracciones, los datos para poder realizar 1900 sumas por segundo se obtenían de tarjetas perforadas y los resultados se almacenaban en 18,000 tubos en vació. Dicha computadora fue financiada por la Armada de los Estados Unidos, utilizada para calcular todas las tablas de fuego de artillería en la Segunda Guerra Mundial y se dio a conocer al público hasta 1946 [5]. En 1944, Jhon von Neumann propuso la computadora EDVAC (Electronic Discrete Variable Automatic Computer), que era un computador de programa almacenado, sin embargo fue la EDSAC (Electronic Delay Storage Automatic Calculator) el primer computador de programa almacenado del mundo que operaba a escala completa, diseñado por Maurice Wilkes en la Universidad de Cambridge en 1949. Después de la construcción de las primeras máquinas de programa almacenado, en la universidad de Harvard se construyó la Mark III y Mark IV, mismas que utilizaban memorias separadas para instrucciones y datos, esto nos sirvió para poder comprender a las maquinas que conocemos hoy en día con una sola memoria principal pero con caches diferentes para instrucciones y datos. Seguidas de estas computadoras se construyeron las maquinas como UNIVAC I, en 1951, el IBM 701, en 1952. No fue hasta el año de 1971 cuando Intel anunció su primer microprocesador. En 1976 se destapo la computadora Cray-1, pero en 1977 salio la primer maquina personal Apple II, todas estas maquinas, contenían cada vez una mejor tecnología y con ello una mejor arquitectura, lo cual, deriva en incremento en el rendimiento. A partir de la década de los 80’s surge la tecnología RISC en inglés Reduced Instruction Set Computer (computador de repertorio reducido de instrucciones) con la que se obtuvo un rendimiento parecido al de los procesadores CISC en inglés Complex Instruction Set Computer (computador de repertorio complejo de instrucciones). La diferencia principal entre estas dos arquitecturas es la siguiente: en la arquitectura RISC se pueden implementar técnicas intensas de hardware (segmentación) con menos complejidad que si se implementan en la arquitectura CISC, ya que la arquitectura RISC maneja instrucciones de tamaño fijo y la arquitectura CISC maneja tamaños variables en sus instrucciones. Para comprender mejor la diferencia entre CICS y RISC, podemos decir que las dos tecnologías manejaban diferentes modos de ejecutar instrucciones, pero los registros se conservaban del mismo tamaño y dependiendo de la arquitectura que se tuviera, era mayor la cantidad de registros utilizados, así, surgió la idea de desarrollar procesadores de alto rendimiento que ejecuten un mayor número de operaciones con registros.

2

Capítulo 1

Introducción

En la tabla 1.1, se presenta la cronología histórica por generación, donde se describe también la tecnología usada y otras características. Generaciones de las Computadoras Alpha

IBM

X86

Pentium 1 Pentium 2 Pentium 3

Procesadores Superescalares

Pentium 4 Tabla 1.1. Desde 1989 se le da el nombre de familia, a los grupos de procesadores que se mejoran. Con el avance de la tecnología, con la aparición del transistor y con la segmentación en la ejecución de las instrucciones, surgen las arquitecturas superescalares, mismas que se describen en la siguiente sección.

1.2 Procesadores Superescalares Los procesadores superescalares pueden iniciar múltiples instrucciones durante el mismo ciclo de reloj, estos son y han sido de las mejores arquitecturas creadas y producidas por fabricantes de procesadores, desde principios de los 90’s. Un procesador superescalar hace la búsqueda y la decodificación de un grupo de instrucciones al mismo tiempo. Como parte de la etapa de decodificación, el resultado de un salto condicional se predice para asegurar una ejecución continua de operaciones con registros. Los registros son analizados para saber si tiene dependencias de datos y distribuidos a las unidades funcionales de acuerdo al tipo de operación. El siguiente paso, es la ejecución de las operaciones lanzadas simultáneamente a cada una de las unidades funcionales, basándose primero en la disponibilidad de los registros operandos de la instrucción. Esta es la principal característica de los procesadores superescalares, y es llamada dynamic instruction scheduling. Al final, los resultados de las operaciones son reordenados para que puedan ser usados al momento de actualizar el estado de los registros en el correcto orden del programa, orden secuencial, ya que cada instrucción puede ser ejecutada en paralelo con otras instrucciones que requieran el mismo dato, lo que se le llama instruction level paralelism (ILP). 1.2.1 Microarquitectura de un procesador superescalar. La siguiente figura 1.1, muestra los componentes de la arquitectura de un procesador superescalar. Las etapas principales son: búsqueda de instrucciones y predicción 3

Capítulo 1

Introducción

de saltos, decodificación de instrucciones y análisis de dependencias de registros, emisión y ejecución de instrucciones, análisis de operaciones de memoria y ejecución, reordenamiento y retiro de instrucciones. Estas etapas son listadas más o menos en el mismo orden en que las instrucciones son ejecutadas.

1.2.2 Camino de Datos (Data Path) 1.2.2.1 Búsqueda de instrucciones y predicción de saltos La etapa de búsqueda de instrucciones, obtiene instrucciones de la memoria de instrucciones y las proporciona al resto de las etapas del procesamiento. Un banco de registros es una pequeña memoria que contiene registros que son utilizados en la etapa de decodificación [13]. Ya que desde el momento que se decodifica la instrucción se sabe que registraos están contenidos en ella, mismos que serán decodificador y renombrados para liberar las diferentes dependencias que se tengan. Un banco de registros está organizado por el número de registros que contiene; es usado para los registros que se encuentre en una localidad del banco de registros. Búsqueda

Decodificación

Lanzamiento

Ejecución

Postescritura

Unidades funciona_les

Cache de datos

Retiro de instrucciones

Banco de Registros Cache de instrucciones

Renombra decodifica

Ventana de instrucciones

Interfaz de memoria

Reordenamiento y asignación

Figura 1.1.- Etapas de procesamiento de un procesador superescalar

4

Capítulo 1

Introducción

1.3 Modelos Analíticos del Rendimiento de un Procesador. La figura 1.2 es la representación del rendimiento con respecto el tiempo de ejecución[5]. Para explicar el rendimiento, tenemos que el tiempo de ejecución de un programa está dado por el número total de ciclos de CPU necesitados para ejecutar un programa, NTotal, y el tiempo que dura el ciclo de CPU, tCPU. Una forma de comparar la importancia de la variación aparentemente independiente de los parámetros, es la relación entre ellos para minimizar el tiempo del ciclo T, y como consecuencia el tiempo de ejecución. En realidad, la falta de continuidad entre estas variables es debida al lazo existente entre tiempo de ciclo del banco de registros y el tiempo de ciclo del CPU. Un cambio en la organización del banco de registros podría o no afectar el tiempo de ciclo del procesador, dependiendo de los caminos críticos en el diseño. Claramente, si el tiempo del banco no está determinado por tiempo de ciclo del CPU, cualquier cambio en su organización puede mejorar el conteo total de ciclos en forma genérica, proporcionando un nuevo tiempo de ciclo del banco menor o igual que un tiempo de ciclo de CPU sin cambio. Ya que los obstáculos en el banco son claros y poco interesantes cuando el tiempo de ciclo del banco es menor que el tiempo de CPU, podemos consistentemente asumir que el tiempo de ciclo de sistema es determinado por el banco de registros. El tiempo de ciclo de CPU y del sistema son por consecuencia parte mínimo del tiempo de ciclo del banco de registros, y los términos son usados como sinónimos. Tiempo de Ejecución

= =

Conteo de Instrucciones

Conteo de Instrucciones

Conteo de Instrucciones

=

[

X

Conjunto de instrucciones de la Arquitectura

X

(

Ciclos por Instrucción

X

Ciclos de CPU por Instrucciones

Ciclos de CPU por Instrucciones

(

+

Tecnología del Compilador

+

X

Ciclos de Memoria por Instrucción

Referencias por Instrucción

Tiempo de Ciclo

) )] X

Ciclos por

X referencia

Implementac ión del CPU

Tiempo de Ciclo

X

Tiempo de Ciclo

Caché y Jerarquía de Memoria (Banco de registros)

Figura 1.2.- Muestra el tiempo de ejecución.

5

Capítulo 1

Introducción

Para un banco de registros, la cuenta total de ciclos es, en primer orden, una función de la velocidad de banco. Las características primarias de la organización del banco de registros es el tamaño del banco, TBR, su nivel de asociatividad A, el número de conjuntos, S, y la cantidad de registros, CR. La porción del ciclo total medido atribuible a la memoria principal, NMM depende de las características de la memoria, el tamaño del banco de registros, y sorprendentemente, el tiempo de ciclo de CPU. Esta última relación resulta del factor de que algunos de los atributos de la memoria son típicamente especificados en segundos. El más significativo de estos es la latencia (LA) entre el inicio de la búsqueda de la memoria y el inicio de la transferencia de datos solicitados. El número de ciclos desperdiciados por la espera en la memoria principal depende de la latencia expresada en ciclos, denotado por la, el cual es dado por el valor más alto del porcentaje de latencia expresado en segundos y el tiempo de ciclo. La otra característica dominante de la memoria es el porcentaje en el cual los datos pueden ser transferidos hacia y desde la memoria principal. El porcentaje de transferencia, tr en words por ciclo y TR en words por segundo, es actualmente el más pequeño de los tres porcentajes o tasas: la tasa en la cual la memoria puede presentar un dato, la velocidad en la cual el banco acepta el dato, y la tasa máxima de transferencia determinada por las características físicas y eléctricas del diseño (material y construcción). El tiempo utilizado en transferir un dato en una sencilla búsqueda es denominado periodo de transferencia. Esto es igual al porcentaje o tasa del tamaño de búsqueda en words y la tasa de transferencia. La función que relaciona los parámetros de la memoria y el banco en un conteo total de ciclos, viene dada por la expresión: NTotal = g( CR, LA, TR, tCPU )

[1.1]

La relación entre el tiempo de ciclo y los parámetros del banco de registros es la más difícil de cuantificar, primeramente por que es extremadamente dependiente en los niveles más bajos de la implementación. La declaración más fuerte que puede ser hecha es que el tiempo de ciclo es invariante, aunque no en un sentido totalmente estricto, en cada uno de los cuatro parámetros básicos: tamaño, asociatividad, número de conjuntos y tamaño de conjunto: tCPU = h( TBR, S, A, CR )

[1.2]

El tiempo de ciclo mínimo es también influenciado por la complejidad de la lógica de control utilizada en las políticas de búsqueda, escritura y reemplazo. La poca predicción de esta función h, ocasiona que se dificulte determinar cuál es la configuración óptima del banco de registros sin realizar un número de diseños individuales para acercarse a un grado de detalle.

6

Capítulo 1

Introducción

1.3.1 Aproximación Analítica De lo anterior se puede entender que el tiempo de ejecución de una carga de trabajo esta directamente relacionado con el tiempo que se requiere para acceder al sistema de memoria; siendo la memoria principal, banco de registros también almacenado como parte de la memoria cache y la ventana de instrucciones al ser tomado como una pequeña memoria de instrucciones. Por esta razón, si se disminuye el tiempo de acceso a estos elementos, se influye en forma proporcional en el rendimiento del procesador. En el siguiente capítulo, se muestra la forma, metodología y herramientas utilizadas en la evaluación de una arquitectura superescalar y sus posibles modificaciones en pro de un mejor rendimiento. Desde la parición de los primeros computadores, la principal preocupación de los arquitectos de computadoras fue mejorar el rendimiento, sin embargo, con el incremento en el número de transistores contenidos en un solo procesador, por el orden de millones, desde hace aproximadamente seis años, los diseñadores se han preocupado por el consumo de energía que tienen las arquitecturas; es por ello que los grupos de investigación se han enfocado al consumo de energía y éste se ha vuelto uno de los parámetros críticos en el diseño de procesadores. Una gran cantidad de trabajos han sido enfocados en la búsqueda de técnicas que permitan disminuir el nivel de consumo de energía del procesador [11, 13]. En general, existen tres niveles en los que se aplican las técnicas de reducción de consumo de energía:


Sistema: métodos de compresión de datos, manejadores de energía, control de actividades según un orden (agenda), protocolos de acceso medio y particiones del sistema, y control de errores de comunicación.




Arquitectura: hardware paralelo (procesamiento en forma paralela), jerarquía del sistema de memoria, compiladores.




Tecnológico: diseño asíncrono, control de la frecuencia de reloj, reducción de voltaje, reducción de ruteado en el chip.

Para nuestro caso, nos enfocamos en el nivel de arquitectura, donde se manejan diferentes modelos, y se puede comprender mejor el impacto de cada uno atendiendo a la siguiente fórmula:

Pd = Ceff V2fα

Esta fórmula corresponde al cálculo de consumo de energía dinámico en tecnología CMOS (85 a 90%) en una primera aproximación, donde: Pd : es el consumo de energía en watts Ceff : es la capacitancia efectiva en Faradios 7

Capítulo 1

Introducción V : es la alimentación de voltaje en Volts, y f : es la frecuencia de operación en Hertz.

De estos factores, el único que es posible modificar a nivel de arquitectura es la capacitancia (Ceff), ya que ésta a su vez está dada por la siguiente fórmula:

Ceff = αC Donde:

C es la capacitancia de carga/descarga y α es la actividad correspondiente al número de transiciones por compuerta.

Si se reduce el número de operaciones realizadas, disminuye por consecuencia la actividad (α) y así en forma directa el consumo de energía. Siguiendo este razonamiento queda sustentada la razón para disminuir el número de lecturas de registros (zero) sin afectar el rendimiento.

8

Capítulo 2

Banco de Registros

2 CAPÍTULO

Banco de Registros

Resumen: En este capítulo, se describe, en forma general, el impacto que tiene el banco de registros dentro de los procesadores superescalares, y de manera particular, su estructura para conocer como se realiza un acceso de lectura y de escritura dentro del mismo. También se conoce el contenido de un registro a nivel transistor, haciendo un análisis detallado de la transición de 1 a 0 de los bit’s que lo conforman. Se da una explicación del consumo de energía con base en el comportamiento del bit. Se detalla paso a paso el comportamiento de su estructura, la cual ayudo a comprender la relación que existe entre los voltajes dentro del banco de registros. Se describe la transición que tiene un bit dentro de un registro, para tener una mejor visión de consumo de energía que existe al leer y escribir un dato dentro del banco de registros. Una vez que se explica en forma general la funcionalidad del banco registros, se describe la importancia que tiene una lectura y escritura de los registros físicos y lógicos que se encuentran contenidos dentro del banco de registros.

9

Capítulo 2

Banco de Registros

2.1 Introducción La importancia que tiene el banco de registros dentro de los procesadores es fundamental para su buen funcionamiento, debido a la aportación de los datos que este hace para poder ejecutar las instrucciones. Como ejemplo tenemos los procesadores PowerPc (fig. 2.1), Mips R10000 (fig. 2.2) y Alpha 21264 (fig. 2.3) [7]. FX: Unidad de Enteros FP: Unidad de punto flotante RS: Estación de reserva ROB: Reorder buffer

I-cache

Búsqueda y Predecodificación de Instrucciones

I-Buffer Decodificación / Uso FX

Decodificación / Uso FP

FX

Despacho de Instrucciones

RS

RS

RS

RS

RS

RS

Ejecución

ALU

ALU

ALU

ALU

ALU

ALU

FP

ROB

Figura 2.1. Arquitectura PowerPc.

A-INT: Unidad de operaciones enteras A-FP: Unidad de operaciones flotantes FX: Registros enteros FP: Registros de punto flotantes ROB: Reorder Buffer

I-Cache

Búsqueda de Instrucciones

Decodificación / Uso

Decodificación / Uso

FX Renombramiento

Estación de reserva

FP Renombramiento

Estación de reserva

Despacho de Instrucciones

Estación de reserva

FX

Ejecución

FP

A-INT

A-INT

A-INT

A-FP

A-FP

A-FP

A-FP

Sobre-escritura TLB

ROB

Figura 2.2. Arquitectura Mips R10000.

10

Capítulo 2

Banco de Registros

RFI: Banco de registros enteros. RFP: Banco de registros de punto flotante. Predicción de Saltos

Estación de reserva

Ren. de Registros Enteros

Ejecució n de enteros

RFI

Ejecució n de enteros Ejecució n de enteros

RFI

Cache de datos

Segundo nivel de la Cache

Ejecució n de enteros

Predicción de Instrucciones de la cache

Estación de reserva

Ren. de Registros fp

RFP

Ejecución de Punto Flotante Ejecución de Punto Flotante

Figura 2.3. Arquitectura Alpha 21264. De los tres procesadores mencionados anteriormente, se tomó el modelo del procesador Alpha 21264, debido a que es uno de los procesadores superescalares más completos en su arquitectura, ya que ejecuta instrucciones fuera de orden, contiene múltiples bancos de registros, contiene múltiples unidades funcionales, las cuales realizan operaciones independientes, etc. También se debe mencionar que el modelo del alpha 21264 se utilizará a lo largo de la tesis. El modelo del procesador se representa con un esquema mas general, en donde se hizo una compactación de las diferentes etapas, y se hace hincapié en los dos bancos de registros que están representados en un solo banco como se muestra en la figura 2.4, el cual, es utilizado para explicar el uso del banco de registros

Tabla de mapeo

Estación de

Banco de Registros

Reserva

Dispatch y Renombramiento

Unidades Funcionales

Figura 2.4.- Arquitectura Alpha 21264.

11

Capítulo 2

Banco de Registros

2.2 Banco de registros. Un banco de registros es un espacio de almacenamiento igual que una memoria, la cual contiene datos y la diferencia que tiene de una memoria cache, es que los datos se encuentran mas cercanos, debido a que el tiempo de acceso es mas corto cuando se tiene un acceso al banco de registros. Los registros son utilizados para resolver operaciones que son ejecutadas mediante instrucciones, sin embargo muchas de ellas tienen dependencias, las cuales son liberadas mediante el renombramiento. Hay que recordar que los procesadores superescalares ejecutan las instrucciones fuera de orden, esto quiere decir que sin un dispositivo de reordenación de instrucciones, en inglés reorder buffer (ROB) que mantenga el orden secuencial de ejecución, muchas operaciones entregarían resultados erróneos. El ROB mantiene un historial detallado del orden de cada ejecución que se hace para cada una de las instrucciones, lo cual quiere decir, que si una de las instrucciones tuvo un resultado incorrecto, el ROB se encarga de indicarle a la ventana de instrucciones que necesita volver a mandar a ejecutar la instrucción con los datos contenidos dentro de los registros o volver a renombrarlos para poder obtener un resultado correcto. Por ejemplo: En el procesador alpha 21264 el banco de registros contiene 32 registros enteros y 64 de punto flotante, su rendimiento se basa en el orden (ROB) y en el menor tiempo de accesos que se requieran al banco de registros para la ejecución de las instrucciones, lo cual indica un beneficio en el rendimiento. Es importante mencionar que entre mejor sea el rendimiento, mayor es el consumo de energía dentro del procesador, el cual es reflejado en el calentamiento que emiten las computadoras, por lo que cada vez se intenta disminuir el consumo de energía, pero la consecuencia es el decremento del rendimiento o lo que es igual a la lentitud en el procesamiento de las aplicaciones en las computadoras. Con lo mencionado anteriormente, se justifica que el banco de registros tiene gran influencia en el rendimiento y en el consumo de energía, sin embargo, en esta tesis se analizarán ambos factores para tratar de mantener por lo menos el mismo rendimiento al reducir el consumo de energía, pero dándole más importancia a la disminución de energía.

12

Capítulo 2

Banco de Registros

2.3 Estructura de un Banco de Registros En todos los procesadores superescalares el banco de registros tiene una estructura, la cual es determinada por la cantidad de registros y el tamaño de los mismos. Dentro de las arquitecturas de los procesadores antes mencionados se observa que contiene diferentes cantidades de registros dentro de sus bancos, sin embargo el tamaño puede variar en 8, 16, 32 y 64 bit`s, como se muestra en la fig. 2.5, todo depende la arquitectura de cada procesador. En el caso del Alpha 21264, los tamaños son de 32 y 64 bit´s exclusivamente. En las etapas de ejecución de una instrucción donde se requiere leer o escribir en los registros, se hace mediante puertos de lectura y escritura, los cuales, se encuentran físicamente contenidos dentro del banco de registros. Se menciona esto debido a que por cada acceso que se realiza, se tiene un consumo de energía; tomando en cuenta que durante la ejecución de un programa, un procesador no lee y escribe solo un registro sino millones de ellos, ya que ejecutan millones de instrucciones, el consumo de energía crece de forma proporcional a la lectura y escritura en el archivo de registros [3, 16]. R1 R2

R1 para la arquitectura de 8 bit’s.

R1 R2

R1 para la arquitectura de 16 bit’s.

R32

R1 R2

R1 para la arquitectura de 32 bit’s.

0101010101010101

01010101

R32

R1 R2

0101010101010101 0101010101010101

R32

a)

R1 para la arquitectura de 64 bit’s. 0101010101010101 0101010101010101 …………………01

R32

b)

c)

d)

Figura 2.5. Registros de a) 8 bit’s, b) 16 bit’s, c) 32 bit’s y d) 64 bit’s. Para poder tener más lucida la explicación de por que existe un consumo de energía al realizar accesos al banco de registros, se explicará lo siguiente: Al leer un registro se tiene un consumo de energía, ya que los datos están formados por múltiples celdas físicas y éstas a su vez están conformadas por una serie de transistores, como se muestra en la fig. 2.6. R1 b

R2

b b

R3

b b

Representación del Registro a nivel transistor

b

b

…… ..….. WL

Representación del Registro en bloques

Rn

b

WL

6 Transistores

WL

6 Transistores

WL

6 Transistores

..........

6 Transistores

Figura 2.6. Estructura interna de un registro a nivel transistor. Los datos contenidos dentro de los registros están representados por diferentes combinaciones de bit´s, y cada bit esta formado físicamente por un arreglo de 6 transistores. 13

Capítulo 2

Banco de Registros

Un bit entrega dos valores que son 1 y 0, y al hacerlo se consume energía, pero la explicación de cómo se obtiene el valor y el consumo dentro del bit a nivel transistor es la siguiente: Para poder entender como se obtiene un valor de 1 y 0, primero se explicara con un inversor como se muestra en la fig. 2.7, ya que dentro de la arquitectura de un bit, el almacenamiento del dato se da mediante una conexión en paralelo de dos inversores (fig. 2.9). El símbolo lógico de un inversor se muestra en la fig. 2.7(a) [17], en donde se aprecia que si el valor de entrada es cero, se invierte el valor colocando un uno en la salida, y cuando se tiene un uno en la entrada, pasa exactamente lo mismo que con el cero, se invierte y el valor que se entrega en la salida es cero. A nivel transistor el inversor esta formado por un circuito MOSFET tipo p (Mp) y un tipo n (Mn), como se muestra en la figura 2.7 (b), en donde su función consiste en habilitar el Mp si el dato que se espera en el voltaje de salida (Vout) debe de ser un 1, y para el caso en donde se espera un 0 en la salida se habilita el Mn. VDD

A

A Mp

A 0 1

A 1 0

+

V in

a) Nivel compuerta

Mn +

V out

b) Nivel transistor (CMOS)

Figura 2.7. Circuito de un Inversor. En la fig. 2.8, se explica la relación que tienen los voltajes de entrada y de salida con respecto a la transición de cero y uno. Cuando Vin contiene un valor de cero, se deduce que el voltaje que se encuentra entre la fuente y la entrada tiene el mismo valor que Vin, por lo tanto, el voltaje que se encuentra entre la puerta y la fuente del MOSFET tipo n tiene el mismo valor de voltaje que la fuente de alimentación del circuito, y se expresa de la siguientes manera: Vin = 0 =VSGp

∴ VGSn = 1 = VDD Y cuando el inversor realiza la transición, el Mp tiene un incremento de voltaje igual al voltaje de alimentación que se deja pasar a la salida de voltaje (Vout), mientras que Mn es igual a cero, ya que su configuración pone el voltaje a tierra, lo cual indica que Vout es igual a cero debido a la caída de voltaje que se produce; y su expresión es la siguiente:

14

Capítulo 2

Banco de Registros

VSGp = 1 = VDD ∴ Vout = VDD VGSn = 0 ∴ Vout = 0 Una vez que se explicó el comportamiento del inversor, se debe mencionar que la configuración del circuito solo activa uno de los dos MOSFET, el cual permite la obtención del bit 1 ó 0 según lo esperado; pero nunca los dos al mismo tiempo. VDD + V SGp

1 Mp

-

V out

V in + 0

V GSn

-

+ Mn

-

Figura 2.8. Muestra la relación entre voltajes de entrada y salida, cuando se realiza transición del inversor. La fig. 2.9 es la representación de un bit que muestra la transición de 1 ó 0 según sea el caso, y al mismo tiempo lo almacena, esto lo hace con ayuda de un latch que se produce mediante la conexión en paralelo de dos inversores. Un latch es conocido como una red biestable, la cual tiene dos estados estables (1 y 0) asociados con el voltaje de entrada (Vin). Bit de línea 1

Latch

0

Latch 1

Transistores de activación

0

Transistores de activación

Figura 2.9.- Muestra la configuración interna de un bit. Esto quiere decir que __ si en la entrada, ahora representados por el bit de línea (BIT) y el bit de línea negado (BIT), fueran leídos (WL) solo se habilitarían los transistores de salida correspondientes al dato contenido dentro de él, por ejemplo: Si el dato contenido

15

Capítulo 2

Banco de Registros

__ dentro del bit fuera igual a 1, el bit de línea (BIT) y el bit de línea negado (BIT) se habilitarían, pero solo se dejaría pasar el voltaje correspondiente al circuito MOSFET tipo p, ya que el transistor de salida correspondiente al circuito es habilitado por el bit de línea (BIT), sin embargo cuando el dato contenido es un 0, solo se activara el transistor de salida correspondiente al circuito MOSFET tipo n, el cual es habilitado por el bit de línea negado __ BIT. El consumo de energía que se tiene en la transición de 1-0 ó 0-1 se da con base en la configuración interna del banco de registros, por ejemplo: Si la configuración del banco establece que se energizara una vez que se alimente de energía el procesador, la lectura del bit con valor de 1 (fig. 2.10), no tendría un incremento de consumo de energía, ya que no se produciría ninguna transición, dejando pasar el mismo voltaje con el que esta alimentado, sin embargo cuando el valor del bit es cero la transición que se genera de “1 a 0”, conduce el voltaje a tierra, produciendo un cambio de voltaje, el cual es reflejado en el calor que genera el procesador. VDD

BIT

_

VDD

Mp

BIT Mp

1

0

1

0 Mn

Mn

Figura 2.10. Diagrama del bit a nivel transistor, el cual muestra la transición de 1 y 0. VDD

VDD

Mp

Mp 1 Vout

Vin

Vout

Vin

0 Mn

Se carga

Mn

Se descarga

a) b) Figura 2.11. Muestra la transición que se realiza dentro del bit.

16

Capítulo 2

Banco de Registros

Tomando como ejemplo la fig. 2.10, se explicará con mas detalle lo antes __ mencionado; se observa que el BIT contiene en su entrada un uno y el BIT un cero, y pensando que el bit contiene un valor de uno, cuando se realiza la lectura del bit solo se activará el transistor del Mp, dejando pasar el voltaje de alimentación a través de la salida del bit de línea (BIT), lo cual indica que no hubo ninguna transición o switching; como se muestra en la fig. 2.11(a). Sin embargo, cuando se hace la lectura del bit, pero ahora con un valor de cero, se tendrá un consumo de energía, ya que se producirá un cambio de voltaje en el switcheo de la transición de 1 a 0 (fig. 2.11 (b)). El cambio indica que la descarga del circuito es conducida hacia el disipador de calor. Así, queda establecido que el análisis del consumo de energía dentro del banco de registros con respecto al rendimiento, es un factor importante, debido a que las arquitecturas actuales van aumentando su estructura día con día. 2.3.1 Registros de Lectura y Escritura Anteriormente se explicó el funcionamiento general del banco de registros, pero ahora se explicará con más detalle cómo se realiza un acceso de lectura y un acceso de escritura dentro de él[2]. Físicamente el banco de registros esta conformado con puertos, los cuales están designados para leer y escribir datos. Cuando se tiene una lectura, realmente se realiza una búsqueda para poder encontrar un dato contenido dentro de algún registro, un claro ejemplo de ello, se muestra en la fig. 2.12, la cual, indica tres instrucciones diferentes. La primera instrucción es una suma que contiene dos registros fuente (r1 y r2) y un registro destino (r6), los registros fuente se leen del banco de registro y al obtener el dato se envía a las unidades funcionales para efectuar la operación, posteriormente, se escribe el resultado en el registro destino. Mientras que en la tercera operación R1 espera el valor de r1 para realizar la operación, y una vez que r1 adquiere un valor y es renombrado, se escribe dentro del banco. Se observa en la figura que los primeros registros se obtuvieron del grupo de los registros lógicos y el renombramiento se hizo con los registros físicos, lo cual se explicará mas adelante. Hay que mencionar que en la secuencia de todas las operaciones hubo un factor muy importante llamado tiempo. El tiempo intervino a través del pipelined en diferentes ciclos, y fue limitado por la lectura y escritura de todos los registros que alimentaban las operaciones, esto quiere decir, que arquitecturalmente se ocupa más tiempo con los dos puertos de lecturas que con el de escritura.

17

Capítulo 2

Banco de Registros Banco de registros

Actualiza Informació n R1

WI

r1

Instrucciones add r6,r1,r2 add r4,r4,r5

3 Los 8 bits 2 add r4,R4,r5 1 add r1,r2,r3

add r1,r2,r3

R3 R6 R2 RF R5 R1 R4 r3 r2 r1

r6

RL r5 r4

Registros Registros

r1

Figura 2.12.- Muestra como se realiza una lectura y escritura al banco de registros con diferentes operaciones.

2.4 Registros Físicos y Registros Lógicos Sabemos que en todas las arquitecturas los registros son una parte fundamental para efectuar las operaciones que requiera el procesador, es importante recordar, que una de las etapas mas importantes es la de renombramiento, debido a todos los renombramientos que se requieren para liberar dependencias entre instrucciones. Se hace mención a esta etapa, por la gran dependencia que tiene con el banco de registros, ya que el renombramiento de los registros lógicos se hace con los registros físicos, pero para explicar con más detalle este punto se tiene la fig.2.13; la cual, muestra a el banco de registros físicos (RF) y al banco de registros lógicos (RL), esto no quiere decir que los registros se encuentren en diferentes bancos, solo se indican en forma independiente para tener un mejor entendimiento de las funciones que tiene el banco de registros. Como se observa en la fig. 2.13, se tiene una secuencia de pasos, para poder entender como influyen los registros dentro del procesador. La primera etapa que se tiene es la de renombramiento, en donde se renombran todos los registros lógicos con los registros físicos, una vez concluida esta etapa se pasa a la etapa de dispatch donde se despachan todas las instrucciones a la ventana de instrucciones, actualizando constantemente el ROB con el orden de los registros físicos y lógicos que se mandan a ejecutar mediante las instrucciones, ayudando a mantener sin errores todas las ejecuciones del procesador.

18

Capítulo 2

Tabla de mapeo R1 r1 R2 r2 R3 r3 R4 r4 R5 r5 R6 r6 R7 r7

Banco de Registros

n

Actualiza Información R1

n sub R4,R5,R6

3

2

1

Banco de registros Retiro del dato R1

3

WI 2 Dispatch y Renombramiento 1

Instrucciones Instrucciones add R6,R1,R2 add R4,R7,R5 add R6,R1,R2

3 add R6,R1,R2 2 add R4,R7,R5 1 add R1,R2,R3

R3 R6 R2 RF R5 4 R1 R4 r3 r2 r1

r6

RL r5

5

r4

Registros Registros

R1

Figura 2.13.- Muestra los bancos de registros físico y lógico.

19

Capítulo3

Metodología de Evaluación

3 CAPÍTULO

Metodología de Evaluación

Resumen: En este capítulo se describen los simuladores que existen para la línea de investigación de arquitecturas de computadoras y se catalogan según su complejidad. La elección del simulador simplescalar v.3.0[14] se basó en la similitud que tiene con respecto al procesador alpha 21264, ya que los modelos que se propondrán en capítulos siguientes tomaron como principal sustentante el procesador antes mencionado. También se describen las modificaciones que se realizaron dentro del simulador, a nivel de programación, para obtener los modelos propuestos. Para poder evaluar el comportamiento de los modelos propuestos se utilizaron las cargas de trabajo SPEC95[1], las cuales, se detallan en forma general al final del capítulo.

20

Capítulo3

Metodología de Evaluación

3.1 Herramientas de Simulación. La metodología que se eligió fue analizar y evaluar la factibilidad de las propuestas a nivel de simulación. Los arquitectos de computadoras siempre han necesitado herramientas que les permitan variar parámetros de los procesadores actuales, esto es necesario para poder proponer mejoras en el rendimiento y la reducción del consumo de energía, evitando la construcción de prototipos que puedan fallar, tomando en cuenta lo costos que ocasionan. Hoy en día existen microprocesadores que tienen una gran complejidad en su arquitectura, trayendo con esto evaluaciones difíciles de realizar. Por lo tanto, es necesario contar con herramientas de simulación que permitan emularlos para mejorar su diseño y rendimiento. Con la simulación, se evita la pérdida de tiempo y dinero que se requiere para desarrollar un prototipo, un claro ejemplo, se da con las malas implementaciones de los diferentes chips, ocasionando una gran perdida monetaria ya que se deben de reconstruir nuevamente sin dejar a un lado que posiblemente pueda fallar nuevamente, pero con los simuladores solo basta con variar algún parámetro en el simulador. Se han creado una gran variedad de simuladores que cuentan con diferentes técnicas de simulación, las que difieren dependiendo de lo complejo que sea el prototipo a evaluar. Algunos realizan las simulaciones por traza, por emulación, por ejecución, entre otras. 3.1.1 Descripción de simuladores para arquitecturas de procesadores. Cada uno de los simuladores difiere en lo complejo o flexible de su código, el soporte técnico, y visualización, así como en su nivel de aplicación. Para un mejor entendimiento explicaremos los simuladores que existen de menor a mayor complejidad. Algunos de los simuladores cuentan con funciones sencillas para la comprensión de los estudiantes que no tienen conocimientos sobre arquitectura de microprocesadores, estos simuladores solo muestran de forma sencilla la organización de un procesador sin profundizar en detalles. Algunas características de estos simuladores son: 1. Visualización de los componentes y el funcionamiento entre ellos. 2. Un lenguaje de conjunto de instrucciones simplificado. 3. Accesibilidad y uso sencillo. La finalidad de estos simuladores es tener un conocimiento básico para poder encaminarse a otros simuladores que realicen más tareas que obviamente implican mayor complejidad. A continuación se muestra la tabla 3.1, la cual describe los simuladores de fácil comprensión existentes. Tabla 3.1. Simuladores de fácil comprensión. Nombre Babbage’s Analytical Engine http://www.fourmilab.ch/babbage/applet.html (John Walker/Fourmilab Switzerland)

Descripción Un applet de Java que emula el mecanismo de una computadora llamada Analytical Engine de Charles Babbage.

21

Capítulo3 CASLE (Compiler/Architecture Simulation for Learning and Experience) http://shay.ecn.purdue.edu/~casle/ (Purdue University) CPU/Disk Subsystem http://www.cis.ufl.edu/~fishwick/CPUDisk/ (Paul Fishwick/U Florida) CPU SIM http://www.cs.colby.edu/~djskrien/ (Dale Skrien/Colby College) CPU Simulator applet http://www.cs.gordon.edu/courses/cs111/module6/cpusim/cpusim.html (Irvin Levy/Gordon College) EasyCPU http://www.cteh.ac.il/departments/education/cpu.html (Cecile Yehezkel/Weizman Institute of Science) Little Man Computer www.acs.ilstu.edu/faculty/javila/lmc/ (Bill Yurcik and Larry Brumbaugh/Illinois State U.) Simple Computer http://beachstudios.com/sc/ (Beach Studios) (utilizado en Saddleback College y Cal State Fullerton) CPU Simulator for Windows http://www.spasoft.co.uk/cpusim.html (SPA Corp.)

Metodología de Evaluación Un script CGI y un simulador a nivel de lenguaje de máquina. La memoria y los registros lógicos son visibles conforme se ejecuta la carga de trabajo. Simulación basada en diseño Web, que representa con un servidor a un procesador y con otros servidores representa múltiples discos. Simulador de CPU basado en el procesador MC680X0 o Power PC. Simulador visual, que representa los principales componentes de la arquitectura de un procesador, junto con sus señales. Conjunto de ventanas basado en el conjunto de instrucciones del procesador Intel 80X86 con modo básico y avanzado. Simula el modelo Little Man Computer de Madnick (1965) del MIT. Ensamble código maquina y lo simula paso a paso. Estado de registros visible. Presenta una ventana en la que se visualiza el estado de los registros, acumulador, IR (Instruction Register), PC (Program Counter) y la memoria. Simula al Simple Computer pero de forma animada.

Después de haber descrito los simuladores de fácil comprensión, pasamos ahora a explicar la descripción de los simuladores que tienen un grado intermedio de complejidad, los cuales se necesitan para tener una mejor visión de la arquitectura de un microprocesador, no obstante, cabe mencionar que deben ser operados por personas que tengan un mayor conocimiento. Algunos de los simuladores presentados en la tabla 3.2, emulan las instrucciones que han sido programadas, mostrando el contenido de la memoria, registros lógicos, el registro de instrucciones, y el contador del programa conforme se ejecuta cada instrucción. La mayoría de estos simuladores son gratuitos. Tabla 3.2. Simuladores de complejidad media. Nombre Simuladores a nivel de instrucciones LC2 Simulator http://www.mhhe.com/patt/ SPIM http://www.cs.wisc.edu/~larus/spim.html (James Larus/U Wisconsin-Microsoft Research) SPIMSAL http://www.cs.wisc.edu/~larus/spim.html (James Larus/U Wisconsin-Microsoft Research) THRSim11 http://www.hc11.demon.nl/thrsim11/thrsim11.htm (Harry Broeders/Rijswijk Inst. of Technology) Microprocessor Simulator http://www.softwareforeducation.com/simulator.htm (Software for Education) Simuladores de Microarquitecturas Mic-1 Simulator http://www.ontko.com/mic1/

Descripción Este simulador representa el procesador presentado por Patt y Patel en su libro Introduction to Computer Systems. Un simulador de lenguaje ensamblador para el procesador MIPS (R2000/R3000) con interfase en modo texto y gráfico[9]. SPIMSAL es una vieja versión de SPIM que corre en Windows 3.12 y Macintosh[8]. Un simulador a nivel de instrucciones del microcontrolador de Motorola 68HC11A8, simulando sus registros, puertos, terminales y memoria. Este es un programa tipo shareware que simula el conjunto de instrucciones del procesador Intel 8086, muy popular en el ámbito académico. Es un simulador del Mic-1 descrito en el capítulo 4 del libro de texto de Tanenbaum

22

Capítulo3

Metodología de Evaluación

(escrito por Ray Ontko y Dan Stone con mejoras de Andrew S. Tanenbaum) Micro Architecture http://www.kagi.com/fab/msim.html (Fabrizio Oddone) (used at Earlham College) MIPSim http://mouse.vlsivie.tuwien.ac.at/lehre/rechnerarchitekturen/download/Simulatoren/ (Institut fur Technische Informatik)

en 1998. Existen versiones para Windows y Unix. Este simulador representa un procesador microprogramado similar al descrito en el libro de Tanenbaum de 1999[4], Structured Computer Organization. Un simulador de un procesador con pipeline, basado en el libro de Hennesy y Patterson en 1996 [9], Computer Organization and Design.

Por último, se mencionan los simuladores de gran complejidad, éstos requieren que las personas tengan un amplio conocimiento de arquitectura de microprocesadores. Los simuladores que pertenecen a este grupo, tienden a reflejar el estado del arte de los procesadores, implementando los modelos de procesadores actuales y son empleados como herramientas de investigación para el diseño de nuevas arquitecturas; se describen en la tabla 3.3. Tabla 3.3. Simuladores de gran complejidad. Nombre Simuladores de micro arquitecturas avanzados DLXsim www.mkp.com/books_catalog/ca/hp2e_res.htm (DLX Processor of [Hennesey and Patterson 1996] Computer Architecture book) DLXview http://yara.ecn.purdue.edu/~teamaaa/dlxview/ (Purdue) RSIM http://www-ece.rice.edu/~rsim/ (Rice) SimOS http://simos.stanford.edu/ (Stanford) SimpleScalar http://www.simplescalar.com/ (Todd Austin, Wisconsin) Simuladores Lógicos LogicWorks http://www.capilano.com/LogicWorks Multimedia Logic Kits www.softronix.com/logic.html WinBreadboard http://www.yoeric.com/ (YOERIC software)

Descripción Un simulador de un procesador DLX, basado en el libro de Hennesy y Patterson en 1996, Computer Organization and Design. Una modificación del DLXsim que presenta una interfaz gráfica e interactiva. Este simulador presenta la ventaja de simular dos vertientes de diseño de procesadores: procesadores que explotan el ILP (nivel de paralelismo de instrucciones) y sistemas multiprocesadores con memoria compartida. Es un ambiente de simulación, que recrea la interacción entre CPU, caches, buses, discos duros, ethernet, consolas y otros dispositivos. Es un conjunto de herramientas: compilador, enlazador, simulador y herramientas de visualización. El simulador más complejo es el denominado sim-outorder. Herramienta para crear, editar y probar circuitos de diseño lógico. Sistema visual para diseño lógico de pequeños circuitos. Simulador a nivel TTL.

Hay que mencionar que estos simuladores incorporan la complejidad de procesadores de alto rendimiento, también se enfocan al comportamiento lógico de una arquitectura, al subdividirse en transistores, compuertas lógicas y circuitos digitales. 3.1.2 Selección de la herramienta de simulación. Para poder desarrollar un modelo, se debe de contar con un simulador que contenga todos los elementos de un procesador superescalar. Los más indicados son los de gran complejidad, ya que reúnen las características necesarias para poder crear un modelo o prototipo, pero de todos lo que se mencionaron, el que se eligió fue el simplescalar 3.0, ya

23

Capítulo3

Metodología de Evaluación

que cuenta con funciones creadas mediante código de programación (lenguaje “C”), formando las mismas etapas de un procesador real. Es un software gratuito que funciona mediante el sistema operativo de Linux, ya que su código sólo se compila con las versiones de gcc que contiene el sistema. También su código puede ser modificado para representar algún diseño en específico, como por ejemplo: un procesador PENTIUM, AMD, MIPS, etc. Sin embargo el simulador se puede configurar en maquinas PISA y ALPHA 21264. El simulador es de simple ejecución, esto quiere decir que una vez que se haya configurado, el simulador se ejecutará paso a paso como un procesador real y entregara datos estadísticos, los cuales son muy aproximados a una maquina real. Una de las grandes ventajas que tiene el simulador, es que todos los diseños que se crean con él, se pueden simular en el simulador wattch[6], para poder obtener resultados de consumo de potencia. Con lo ya mencionado, se deduce que la herramienta simplescalar contiene lo necesario para el diseño de nuevos modelos de procesadores, prueba de ello es que aproximadamente un 70% de los diseñadores de arquitectura utilizan esta herramienta para sus investigaciones. De la lista presentada en la tabla anterior, se seleccionó el conjunto de herramientas que proporciona el Simplescalar Toolset, y en especial su herramienta denominada “simoutorder” por las siguientes características:











Ejecución fuera de orden. Predicción de saltos. Recuperación de estado después de un error de especulación (error de salto y ejecución posterior en forma especulativa). Representación de unidades funcionales con latencias de operación. Representación de jerarquía de memoria (caché de datos e instrucciones) con latencias de acceso dependiendo de acierto o fallo en la búsqueda. Uso de tablas de traducción para las direcciones de las memorias cache. Implementación de un Reorder Buffer y una ventana centralizada de instrucciones en un elemento denominado RUU. Entrega de estadísticas de ejecución. Fácil manipulación de código (3900 líneas código en lenguaje C). Representación de dos arquitecturas: PISA (arquitectura ficticia) y ALPHA (arquitectura basada en los procesadores Alpha).

24

Capítulo3

Metodología de Evaluación

El simulador “sim-outorder” recrea la simulación de la arquitectura por bloques que realiza una tarea específica. En la figura 3.1 se muestra el seguimiento de cada una de las etapas de acuerdo a los módulos del procesador.

Búsqueda

Decodificación

I-Cache (IL1)

I-TLB

Ventana de instrucciones

Ejecución

Accesos a memoria

Operaciones de memoria

Banco de Registros

I-Cache (IL2)

D-Cache (DL1)

Postescritua

Retiro de instrucciones

D-TLB

D-Cache (DL2)

Memoria Virtual

Figura 3.1 Diagrama esquemático del simulador “sim-outorder” del Simplescalar. La herramienta Simplescalar cuenta con un conjunto de simuladores, lo cuales se explican en 3.4. Tabla 3.4 Conjunto de simuladores de Simplescalar. Simulador

Sim-Safe Sim-Fast Sim-Profile Sim-Cache Sim-Cheetah

Descripción

Implementación de un simulador funcional. Es el simulador más sencillo y amigable de todo el conjunto de herramientas. Simulador funcional, el más veloz del conjunto de instrucciones, no verifica posibles errores en la simulación, por lo que no es 100% confiable. Simulador funcional, que presenta mensajes sobre el tipo de instrucción que se esta ejecutando en el momento (profiling). Simulador funcional de una memoria caché. Las estadísticas son acordes al tipo de memoria y configuración que da el usuario al programa. Simulador funcional de una memoria tipo Cheetah, desarrollada por Rabin Sugumar y Santoch Abraham, la cual puede simular eficientemente de forma simultánea caché de mapeo directo, asociativas y completamente asociativas.

25

Capítulo3

Metodología de Evaluación

Todos los simuladores presentados en la tabla 3.4, o por lo menos sus partes esenciales, se encuentran en el simulador sim-outorder, permitiendo una simulación confiable y completa de la operación. superescalares. El “sim-outorder” simula un procesador con las siguientes opciones de configuración de la arquitectura: -fetch:ifqsize -fetch:mplat -bpred -decode:width -issue:width -issue:inorder -issue:wrongpath -ruu:size -lsq:size -cache:dl1 -cache:dl1lat -cache:dl2 -cache:dl2lat -cache:il1 -cache:il1lat -cache:il2 -cache:il2lat -cache:flush -cache:icompress -mem:lat -mem:width -tlb:itlb -tlb:dtlb -tlb:lat -res:ialu -res:imult -res:memports -res:fpalu -res:fpmult -pcstat -ptrace

Tamaño del buffer de búsqueda de instrucciones. Latencia (ciclos) de un error de predicción de salto. Especifica el tipo de predictor de saltos. Ancho de banda del decodificador de instrucciones. Ancho de banda de instrucciones lanzadas a ejecutar. Ejecución de instrucciones en orden. Número de instrucciones permitidas que se lanzan después de un error de predicción o especulativo. Tamaño de la ventana de instrucciones (ROB y RS). Capacidad de la cola de instrucciones de memoria. Configuración de caché de datos de nivel 1. Latencia de acierto de caché de datos de nivel 1. Configuración de caché de datos de nivel 2. Latencia de acierto de caché de datos de nivel 2. Configuración de caché de instrucciones de nivel 1 Latencia de acierto de caché de instrucciones de nivel 1. Configuración de caché de instrucciones de nivel 2. Latencia de acierto de caché de instrucciones de nivel 2. Actualiza todas las caché s con llamadas al sistema. Mapea dirección de 64 bits con su equivalente de 32. Específica latencia de acceso a memoria. Ancho de bus de memoria (bits). Configuración del TLB de instrucciones. Configuración del TLB de datos. Latencia de servicio de un error en el TLB. Número de ALU’s para enteros. Número de unidades para multiplicar/dividir enteros. Número de puertos de la caché de primer nivel. Número de ALU’s para punto flotante. Número de unidades para multiplicar/dividir punto flotante. Graba estadísticas de una dirección de programa (texto). Genera traza de ejecución.

26

Capítulo3

Metodología de Evaluación

La arquitectura simulada cuenta con un tamaño de instrucción de 64 bits, 32 registros para enteros (32 bits c/u), 32 registros para números de punto flotante de simple precisión (32 bits c/u) o 16 registros de punto flotante de doble precisión (64 bits c/u), y cuatro registros especiales (Program Counter o PC, LO, HI y FCC), los cuales son representados en forma general mediante la fig. 3.2. Banco de registros de punto flotante

Banco de registros enteros r0 (32 bits) r1

f0 (32 bits) f1

PC

r2 . . .

f1

f2

f3

f30

f31

LO HI

r30

FCC

r31

f31 Simple

y

Doble precisión

Figura 3.2.- Bloques de registros enteros y de punto flotante de la arquitectura simulada por “sim-outorder”. La implementación del simulador está conformada por varios módulos, los cuales se muestran en la figura 3.3. Cada uno de los componentes 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, teniendo varios tipos de predictores disponibles. El módulo “Resource” cuenta con las rutinas para manejo de recursos como son unidades funcionales y la ventana de instrucciones. El módulo “EventQ” tiene la implementación de rutinas para el manejo de las colas de la arquitectura (colas de instrucciones de carga y almacena, instrucciones en espera de un operando, instrucciones retiradas del ROB). El módulo “Loader” es el primero en tener contacto con el programa de carga que se le asigna al simulador, ya que se encarga de actualizar los valores en la memoria virtual simulada.

Bpred

Stats

Simulador Core o núcleo

Resource EventQ

Cache Loader

Regs

Memory

Figura 3.3.- Módulos que conforman el simulador “Sim-Outorder”.

27

Capítulo3

Metodología de Evaluación

El módulo “Regs” cuenta con la implementación de los registros de la arquitectura. El módulo “Memory” tiene las rutinas de manejo del espacio de memoria virtual simulado, además de las operaciones propias del segmento de memoria. El módulo “Cache” tiene la implementación de la memoria caché de datos, instrucciones y TLB, además de las rutinas de acceso a dicho elementos y rutinas de actualización. El módulo “Stats” tiene el manejo de las estadísticas del simulador (contadores, variables, distribuciones y expresiones). Cuando se requiere evaluar un diseño, se adecua la herramienta de simulación para que simule una arquitectura propuesta por el diseñador. En el caso de que la modificación tenga impacto en la jerarquía de memoria, el módulo afectado es “Regs”. Sin embargo en el caso de modificar la forma en que se lleva acabo cada uno de los pasos del datapath se requiere modificar el núcleo del módulo denominado simulador core. La fig. 3.4 muestra las funciones asignadas a las etapas del procesador, sin embargo las más importantes para la optimización del banco de registros son: 1. ruu_fetch( ) 2. ruu_dispatch( ) 3. ruu_issue ( ) 4. ruu_writeback ( ) 5. ruu_commit ( ) Carga de valores iniciales Ciclo infinito o hasta que no existan mas instrucciones a simular Retiro de instrucciones Decodificación, renombramiento y despacho de instrucciones

Postescritura de resultados

ruu_init() for (;;) { ruu_commit(); ruu_writeback(); lsq_refresh(); ruu_issue(); ruu_dispatch(); ruu_fetch(); }

Manejo de instrucciones de memoria Lanzamiento de instrucciones a ejecutar Búsqueda de instrucciones

Figura 3.4 Funciones que emulan las etapas del procesador en el simulador Core o Núcleo. La forma de trabajo es la siguiente: El simulador utiliza la función ruu_fetch, para realizar la búsqueda de los registros que necesitan las instrucciones, y al mismo tiempo realiza las operaciones. La función ruu_dispatch tiene un importante papel dentro del simulador ya que realiza el renombramiento de los registros, decodifica y reparte la instrucciones. La función ruu_issue indica el estado de las instrucciones para que puedan ser lanzadas a ejecutar. Una vez que fueron ejecutadas las instrucciones, los resultados son validados por ruu_writeback para su rehusó. Y la función ruu_commit, retira los registros al banco de registros. 28

Capítulo3

Metodología de Evaluación

Las modificaciones que se le hicieron al simulador se muestran en la fig. 3.5, en donde se observa la implementación de nuevas funciones dentro del simulador para obtener datos estadísticos, las cuales indiquen mejorías dentro del procesador alpha 21264. También hay que mencionar que fueron creadas con la finalidad de guiarse a través de las funciones principales del simulador, para poder obtener datos específicos sobre los registros; su explicación es la siguiente:

(RUU_fetch)

Búsqueda

(RUU_dispatch)

Decodificación

(RUU_issue)

Ventana de instrucciones

Ejecución

Accesos a memoria

Operaciones de memoria

(RUU_writeback)

Postescritua

(RUU_commit)

Retiro de instrucciones

Banco de Registros

(reg_verifica)

(reg_asigna)

nible

(reg_management)

nible_r

(reg_write)

(reg_libera)

nible_w

Figura. 3.5. Funciones creadas dentro del Simulador. Las funciones que apuntan a ruu_dispatch son: reg_verifica, reg_asigna y reg_management, cada una de ellas se tiene una función diferente, la cual será explicará a continuación: La función reg_verifica sirve para conocer el número total de registros que se utilizaran para resolver las operaciones dentro de las instrucciones. La función reg_asigna tiene la finalidad de contar el número de registros que fueron renombrados, y conocer su tamaño. Dentro del simulador, el ROB esta incluido en la función ruu_dispatch y no esta seccionado independientemente, lo que no permite conocer con detalle el historial del renombramiento, sin embargo, con ayuda de la función reg_management se puede conocer su forma de trabajo de forma independiente. Otra función es reg_write, la cual nos sirve para conocer el número de registros que se reutilizaron en la etapa de postescritura, y la función principal que se encarga de entregar los datos antes mencionados es ruu_writeback. La función que se encarga de la última etapa es ruu_commit y tiene como función principal liberar los datos, sin embargo, la

29

Capítulo3

Metodología de Evaluación

reg_libera que también fue creada, se utilizo para conocer el número total de registros renombrados que se liberaron. Las funciones de nibble, nibble_r y nibble_w, son las mas importantes y laboriosas de todas las que se crearon, ya que su función consiste en conocer las cantidades de nibble’s, byte’s, int’s y word’s que existen dentro de los registros de la arquitectura y renombrados dentro del procesador.

3.2 Cargas de trabajo (Benchmarks) Un benchmark es 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. SPEC CPU95 es un software tipo benchmark producido por Standard Performance Evaluation Corp. (SPEC) que incluye a fabricantes de computadoras, integradores de sistemas, universidades, organizaciones de investigación y otros de todo el mundo. Este software, está 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 3.5. En esta tabla se pueden observar 11 benchmarks de los cuales se tiene la referencia del número de instrucciones y la categoría a la que pertenece cada clase de carga de trabajo. Los benchmarks de tipo punto flotante utilizados son mostrados en la tabla 3.6. Tabla 3.5.- Cargas de trabajo de tipo entero (SPEC95INT). Benchmark Número de instrucciones (sim-safe) m88ksim

78696259339

go

45032374295

compress

64599969967

li

65762809488

gcc

9815097687

ijpeg

111584623217

perl

40241942899

vortex

90180454922

Categoría

Simulador del Motorola 88k: ejecuta un programa de prueba Inteligencia Arficial: juega al go Comprime y descomprime fichero en memoria Interpreta código LISP Nueva versión de gcc, construye código SPARC. Compresión y descompresión de gráficos. Manipula cadenas (anagramas) y números primos en PERL. Base de datos.

Tabla 3.6.- Cargas de trabajo de tipo punto flotante (SPEC95FP). Benchmark Número de instrucciones (sim-safe) Categoría Programa de generación de tramas tomcatv 26707284939 applu

46051881414

apsi

27999179162

su2cor

28387286599

hydro2d

42585845189

turb3d

79680616852

Ecuación diferencial parcial elíptica parabólica Resuelve problemas relacionados con la temperatura, viento, velocidad y distribución de la polución. Física cuántica: simulación de Montecarlo. Astrofísica: ecuación de Navier-Stokes Simulación turbulencia homogénea isotrópica en un cubo

30

Capítulo3

Metodología de Evaluación

fpppp

117968461010

wave5

29889331462

mgrid

72025693903

swim

35023227316

Química cuántica Física de plasmas, simulación de partículas electromagnéticas. Solución multirejilla en un campo potencial en 3 dimensiones Programa de agua poco profunda con rejilla 513x513

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 aplicandosele 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. Los benchmarks se compilaron en un computador basado en el procesador Alpha 21264, con sistema operativo OSF1 V4.0. Para los benchmarks de enteros usamos la opción -04 del compilador “cc” propietario. Los benchmarks de coma flotante se compilaron con la opción -05 del compilador “fortran” propietario y los resultados corresponden con una simulación completa de las cargas de trabajo representativas.

31

Capítulo 4

Optimización del Banco de Registros

4 CAPÍTULO

Disquisición Experimental para la Optimización del Banco de Registros

Resumen:

En este capítulo, se explicará cómo se fundamentan las técnicas de optimización del Banco de Registros propuestas en los siguientes capítulos de esta tesis. Para ello, lo primero que se tuvo que considerar, fue el lugar o la etapa del procesamiento en donde se explota la mayor cantidad de los registros de la arquitectura el procesador. Para poder obtener resultados reales, se hicieron simulaciones del modelo de una arquitectura configurada como un procesador convencional y el resultado que se tuvo con las cargas de trabajo, demostró que se utilizaban en su mayoría registros renombrados, los cuales, provienen del banco de registros, que en esta tesis los llamamos registros físicos. A partir de la idea de seccionar o segmentar los registros para detectar cadenas de ceros, nos permitió deducir que “el patrón del comportamiento de la información que se lee y escribe en el Banco de Registros” permite plantear alternativas que optimicen el banco de registros a través de la reducción de accesos a éste. Los resultados que entregaron las cargas de trabajo, señalan que entre más se reduce la cadena de bits contenida en los registros más detecciones de ceros se tienen.

32

Capítulo 4

Optimización del Banco de Registros

4.1 Introducción Dentro de la arquitectura, los registros viajan por el camino de datos definido de acuerdo a las etapas de procesamiento de un procesador superescalar (ver fig. 4.1). El análisis del recorrido de la información que se almacena en los registros, requiere una caracterización precisa que permita obtener información para su posible optimización. Para obtener los primeros resultados estadísticos se utilizó el simulador simplescalar V.3.0, debido a la flexibilidad de su código “C”, tomando en cuenta que su estructura es la misma al de un procesador superescalar. La fig.4.1, es la representación del simulador, la cual, nos muestra las diferentes etapas en donde se utilizan los registros. Se observa que los principales distribuidores de registros son los bancos de registros físico y lógico (tomando en cuenta que en el simulador se encuentran dentro de la función de RUU_ISSUE). Otro importante distribuidor seria la etapa de postescritura (la cual está contenida en la función de RUU_WRITEBACK dentro del simulador).

Escribe al banco de registros físicos el valor de R1

Banco de Registros Tabla de mapeo

Lectura de datos.

Banco de Registros Físicos

Banco de Registros Lógicos

Actualiza el registro R1

Estación de Reserva R1,R2,R3 Despacho y Renombramiento

Unidades Sub R4,R1,R5

Funcionales Postescritura (writeback)

Add R1,R2,R3

Figura 4.1.-Muestra los puntos que aportan registros al procesador. Para poder obtener resultados estadísticos del consumo de registros, se colocaron tres contadores dentro del simulador, cuya representación gráfica se muestra en la fig.4.4 con las flechas A, B y C. La flecha A contará todos los registros que se utilizan del banco de registros físicos, la flecha B contará todos los registros que aporta el banco de registros lógicos, y la flecha C contará todos los registros esperados por otras operaciones. A

33

Capítulo 4

Optimización del Banco de Registros

continuación se hablará un poco sobre los marcos de referencia que justifica dicho experimento.

4.2 Trabajos Relacionados. Con el tiempo se han realizado estudios sobre el banco de registros con la finalidad de mejorar su funcionamiento, pero las mejorías se han reflejado en incrementos de consumo de energía, por eso se han hecho estudios para poder minimizar y/o estandarizar la energía que consume un procesador. Uno de los estudios fue el diseño de un modelo de energía, el cual diagnosticaba el consumo de energía que se producía en el camino de datos[10]. Para poder tener datos estadísticos de la energía que se consume, se tuvo que clasificar el camino de datos en flipflops, latches, muxes, un banco de registros, unidades funcionales (ALU), sumadores, un desplazador, buffers, y un checador de igualdad, y los resultados que se obtuvieron del modelo de energía se observan en la fig. 4.2, en donde se observa que el banco de registros es uno de los mayores consumidores de energía, dentro de los procesadores superescalares.

Figura 4.2. Consumo de energía en forma general de los diferentes componentes contenidos dentro del procesador. Una vez que se demostró que el banco de registros es uno de los mayores consumidores dentro de los procesadores, se realizaron pruebas mas especifica sobre el consumo de energía que se tiene por cada acceso de lectura y escritura, y los resultados que se obtuvieron son mostrados en la figura 4.3, la cual, indica que los accesos de lecturas consumen la mayor parte de la energía, sin embargo, no hay que descartar los resultados que se obtuvieron del consumo que tienen los accesos de escrituras, ya que aunque son datos específicos, los dos son parte del consumo total de energía que se tiene del banco de registros.

34

Capítulo 4

Optimización del Banco de Registros

Otro de los estudios que se han hecho sobre el consumo de energía, es la “compresión dinámica cero” para la reducción del consumo de energía dentro de la memoria cache[11]. Se hace mención a este estudio debido a que el banco de registros esta directamente relacionado con la información que se escribe y lee en una memoria cache. Esta técnica consistió en detectar con un bit de bandera cadenas de byte’s con valor igual a cero, el cual redujo alrededor de un 26% del consumo de energía total. Es importante mencionar que los trabajos relacionados fueron realizados con diferentes simuladores, utilizando los SPEC 95 para su comprobación de eficiencia[1].

Figura 4.3. Porcentajes de consumo de energía en los diferentes módulos de un procesador. Con lo ya mencionado, se deduce que el proponer técnicas para la reducción del consumo de energía dentro del banco de registros, tiene un fuerte impacto en el diseño de diferentes procesadores superescalares.

4.3 Mayor consumidor de registros.

Banco de Registros Físicos

Tabla de mapeo

A

Banco de Registros Lógicos B

Actualiza el registro R1

Estación de C

Reserva R1,R2,R3 Despacho y Renombramiento

Unidades Funcionales

Figura 4.4.- Muestra la representación de los contadores con las flechas A, B y C.

35

Capítulo 4

Optimización del Banco de Registros

Los resultados obtenidos del simulador, se representaron en la gráfica 4.1, en donde se obtuvo un 64% de utilidad de registros físicos, un 36% en la aportación de registros esperados por otras operaciones y un mínimo de utilidad de registros lógicos. Con los porcentajes se pudo observar que el mayor proveedor de registros dentro de un procesador superescalar es el banco de registros físico.

Mayor consumidor de registros 100% 64%

64%

36% 0,01%

Total de registros usados

Registros usados por WB

Registros usados por BRF

Registros usados por BRL

Registros usados por los dos bancos

Gráfica 4.1.- Porcentaje de registros usados en las etapas de WB (writeback o postescritura), BRF (Banco de registros físico) y BRL (Banco de registros lógico). Con lo mencionado, se proponen ideas para la optimización de los accesos que se tienen a los registros físicos contenidos dentro del banco de registros (BRF) y una de las tantas ideas para poder optimizarlo es la detección de registros con valor igual cero y diferentes de cero. Pero para poder realizar la detección se tuvo que modificar el simulador a nivel de programación, para conocer datos estadísticos de los registros con valor igual y diferente de cero.

4.4 Conteo de los registros cero y diferentes de cero. Para poder explicar este subcapitulo, primero se debe analizar la importancia que tiene la detección de registros con valor igual a cero. Como se sabe dentro de un registro se tiene un conjunto de bit´s con valor igual a 1 y 0, los cuales conforman el dato contenido dentro de él. Si muchos de los registros tuvieran un valor igual a cero, se tendría un conjunto de bit´s con valor igual a cero, indicando un consumo de energía el cual se pude optimizar con técnicas de detección de cero. Para realizar lo mencionado, se colocó un contador dentro del simulador, para poder obtener datos estadísticos de todos los registros con valor igual y diferente de cero. En la fig.4.5 se muestra el contador de forma gráfica (la flecha A es la representación del contador).

36

Capítulo 4

Optimización del Banco de Registros Banco de Registros Tabla de mapeo

Banco de Registros Físicos

Estación de Reserva

Banco de Registros Lógicos

R5=6 R1=0

A

A

R1

R3=0 R2=0

Unidades

R1,R2,R3 Despacho y Renombramiento

Funcionales

Sub R4,R1,R5

Contador de registros 0 y ≠0. Add R1,R2,R3

Figura 4.5.-La figura muestra el contador “A” que se colocó dentro del simulador para contar los registros con valor igual y diferente de cero en las etapas de lectura y escritura al banco de registros físico. Los resultados obtenidos por el simulador, se indican en la gráfica 4.2, donde se observó que en promedio el 41% de los registros se trataban de cadenas de 32 bit´s iguales a cero. Esto nos señalo que casi la mitad de los datos que se utilizaron durante la ejecución de las cargas e trabajo fueron ceros.

32%

21%

Registros cero

41%

io ed m

pr o

m

59%

li

26%

88 ks im

s pr es

38%

co m

sw im

16%

79%

gr id

58%

68%

m

53%

74%

rl

54%

62%

pe

42%

84%

d

u pl ap

eg i jp

ap

24%

47%

rb 3

68%

56%

46%

tu

76%

go

32%

44%

si

Porcentaje

Registros cero por spec y registros cero totales

Registros ≠ cero

Gráfica 4.2.- Muestra la utilidad de registros con valor igual a cero por SPEC y su promedio general. Lo mencionado anteriormente con respecto a la gráfica 2, sólo hizo hincapié a la explicación del promedio de todas las cargas de trabajo, pero como cada SPEC se comporta 37

Capítulo 4

Optimización del Banco de Registros

de diferente manera, se hace mención a la carga ijpeg, la cual, utilizo el 68% de registros con valor igual a cero, siendo la carga de trabajo que mayor consumo de registros con valor igual a cero utilizó y la carga de trabajo que utilizo la menor cantidad de registros cero fue turb3d con solo un 16%. Con lo que se observó en los resultados, se pudo concretizar que la detección de ceros es factible para la optimización del banco de registros. Pero hasta el momento solo se han mostrado detecciones generales de registros con valor igual a cero, esto quiere decir que no se han considerado las detecciones de ceros cuando se tiene un acceso de lectura y/o escritura por separado. Para contemplar por separado los datos, se tuvo que dividir el contador en: el contador A, el cual entrego el conteo de todos los registros cero que se leen y el contador B, el cual entrego el conteo de todos los registros cero que se escriben, ambos contadores son mostrados en la fig. 4.6.

4.5 Registros cero totales de lectura y de escritura BaBanco de Tabla de mapeo bla de

R1R1,R2,R Despacho 3 y Renombramiento spatch

Estación de Reserva

Banco de Registros Físicos nco de R5R5 R1R1 =6 =0 R3R3 R2R2 =0 =0

Banco de Registros Lógicos nco de A

B

R1

Unidades SuSub R4,R1,R5 b R4,R1,R5 Add R1,R2,R3

Funcionales

Contador de accesos de escritura que entregan registros = 0 Contador de accesos de lectura que entregan registros = 0 ntador de accesos

Figura 4.6.- Muestra los contadores de los registros de lectura y escritura con valor igual y diferente de cero. Con el contador A, se obtuvieron los resultados mostrados en gráfica 4.3, la cual indica que el promedio es igual al 41% de registros con valor igual a cero. Pero la carga de trabajo que más registros cero tuvo al tener accesos de lectura fue ijpeg con un 66%, debido a que es una carga de trabajo que realiza sus operaciones con números enteros, caso contrario al SPEC turb3d el cual solo utilizo el 16%, porque que la mayoría de sus operaciones contienen operaciones de punto flotante.

38

Capítulo 4

Optimización del Banco de Registros

27%

34%

23%

o om

pr

Registros ≠ cero de lectura

41%

ed i

sim m

m

Registros cero de lectura

59%

li

40%

88 k

pr es

s

im

77%

gr id

57%

66%

m

54% 16%

73%

rl

53%

60%

pe

43%

co

ap p

ap si

lu

24%

46% 84%

sw

66%

ijp eg

58%

47%

d

76%

rb 3

34%

tu

42%

go

Porcentaje

Gráfica que muestra registros cero de lectura por spec y registros cero totales de lectura

Gráfica 4.3.- Porcentajes de registros con valor igual a cero que se tiene cuando se realiza una lectura por SPEC, y su promedio general. Los resultados del contador B se muestran en la gráfica 4.4, los cuales señalan que se tuvo un 39% de registros físicos con valor igual a cero, que se escribían al banco de registros físicos. La carga de trabajo que mas registros cero utilizo en sus operaciones fue ijpeg con un 75%, ya que utiliza números enteros, caso contrario de la carga de trabajo turb3d, debido a que sólo utilizó un 15% de registros cero en sus operaciones de punto flotante.

Registros cero de escritura

16%

29%

20%

61% 39%

pr

om

ed i

o

li

80%

88 ks im

32%

71%

m

pr es s co

tu rb 3d

15% go

u pl ap

eg i jp

63%

55%

84%

gr id

58% 21%

68%

m

85%

m

75%

37%

45%

pe rl

79%

47%

ap

42%

sw im

25%

53%

si

Porcentaje

Gráfica que muestra registros cero de escritura por spec y registro cero totales de escritura

Registros ≠ cero de lectura

Gráfica 4.4.- Porcentajes de registros con valor igual a cero que se tiene cuando se realiza una escritura por SPEC y su promedio general. Con las explicaciones anteriores de detección de registros con valor igual a cero para accesos de lectura y escritura, se entiende que más de la mitad de los accesos consumen energía, debido a la conversión de “1 a 0” que tienen los bit´s contenidos dentro de los arreglos de transistores. Por lo tanto se pueden proponer diferentes técnicas de detección de ceros, que optimicen los accesos de lectura y escritura que se hacen al banco de registros. 39

Capítulo 4

Optimización del Banco de Registros

4.6 División del Registro en nibble’s, byte’s, int’s y word’s. Con lo anterior, se mostró que la detección de cadenas de registros con valor igual a cero es una buena técnica para poder optimizar el banco de registros, pero ahora se pretende contar cadenas de bits de tamaños menores, para poder obtener mayores cantidades estadísticas de detecciones de ceros. Para poder realizar los conteos, primero se crearon grupos o cadenas de 32 bit´s (word), 16 bit´s (int), 8 bit´s (byte) y 4 bit´s (nibble), los cuales son mostrados en la fig.4.7. La primera cadena llamada word o palabra esta conformada por 32 bit’s, y dentro de esta cadena existen dos cadenas de int’s con un tamaño de 16 bit´s cada una, de igual manera dos cadenas de 8 bit´s o byte´s forman una cadenas de enteros, por lo tanto, dos cadenas de 4 bit´s ó 2 nibble´s forman una cadena de un byte.

32 bit´s 16 bit´s 8 bit´s

nibble

Byte

0000

0000

Int

0110

0000

Word

1010

1110

0010

0011

Figura 4.7.- Representa las cadenas de nibble´s, byte´s, int y word´s, contenidas dentro de un registro de 32 bit´s. Para poder simular debidamente, se tuvo que modificar el código del simplescalar. Esta modificación se hizo a nivel de programación, colocando instrucciones básicas de “C”. El código se colocó en las funciones que realizan el barrido de los 32 bit´s que conforman las cadenas de word, esto se realizó comparando bit por bit de derecha a izquierda. Las primeras simulaciones que se realizaron, fueron para todas las cadenas de palabras (word), y los datos estadísticos son mostrados en la gráfica 4.5. Los resultados indican que el 41%, con granularidad de Word, se trataba de palabras iguales a cero y la carga de trabajo que mayor cantidad de palabras cero utilizo fue ijpeg, el cual, obtuvo un 68% de cadenas de word iguales a cero, a diferencia de la carga de trabajo turb3d la cual utilizo solo un 16% de cadenas con valor igual a.

40

Capítulo 4

Optimización del Banco de Registros

38%

26%

32%

21%

w ord´s ceros

59% 41%

m

pr om

ed io

li

79%

sim

s pr es

68%

88 k

58%

74%

gr id

53% 16%

62%

m

42%

pe rl

54%

ap

i jp

pl

eg

si ap

u

24%

47% 84%

co m

68%

56%

46%

sw im

76%

tu rb 3d

32%

44%

go

Porcentaje

Gráfica que muestra los word´s totales y su promedio

w ord´sdiferentes de cero

Gráfica 4.5.- Porcentaje del uso de las cadenas de word con valor igual a cero y diferente de cero, que se detectaron dentro de los registros usados por la arquitectura. Con los resultados antes mostrados, se puede sustentar la hipótesis de optimizar el banco de registros a través de la detección de cadenas de palabras con valor igual a cero. Todos los resultados mostrados fueron del total de registros utilizados, esto quiere decir que fueron todos los registros que se leen y los que se escriben. De acuerdo a los resultados reportados en la gráfica 4.5, se esperaría que al reducir el tamaño de la cadena de bit´s a detectar como cero, como es el caso de las cadenas de word, cuando se tiene un acceso de lectura y escritura fueran mucho mejores. Para la realización de esta prueba se modificó el simulador, de tal manera que se detectaran todas las cadenas de word con valor igual a cero cuando se lee y se escribe un dato. Los resultados que se obtuvieron de las detecciones de cadenas de word con valor igual a cero cuando se realizan accesos de lecturas al banco de registros, se observan en la gráfica 4.6.

66%

77%

54%

57%

40%

27%

34%

23%

w ord´s ceros de lectura

59%

om

ed io

41%

pr

sim 88 k m

m

s co

m

pr es

im

16%

li

73%

gr id

60%

rl

43%

pe

53%

sw

u pl

eg ij p

si ap

24%

46% 84%

rb 3d

66%

58%

47%

tu

76%

go

34%

42%

ap

Porcentaje

Gráfica que muestra los word´s ceros y difernetes de ceros de lectura

w ord´s diferentes de ceros de lectura

Gráfica 4.6.- Porcentaje de cadenas de word con valor igual a cero y diferente de cero cuando se tiene un acceso de lectura..

41

Capítulo 4

Optimización del Banco de Registros

Los resultados indicaron que se tuvo un 41% de lecturas, con granularidad de word, iguales a cero. La carga de trabajo que utilizó más cadenas de word, que se trataban de palabras iguales a cero, fue ijpeg con un 66%, esto se debe a la mayoría de sus operaciones se realizan con valores enteros. Por otro lado, el SPEC que utilizó la menor parte de cadenas con valor igual a cero, fue turb3d con un 16%, debido a que utiliza números de punto flotante en la mayoría de sus operaciones. Para el caso de escrituras, se muestra la gráfica 4.7, en donde, se observó que en promedio el 39%, con granularidad de Word, fueron palabras iguales a cero, siendo ijpeg la carga de trabajo que utilizó más cadenas de word con valor igual a cero, con un 75%. La carga de trabajo que utilizó la menor cantidad de cadenas de word con valor igual a cero fue turb3d, con un 15%.

32%

16%

29%

20%

61%

om

ed io

39%

pr

sim 88 k

li

80%

m

s co

m

pr es

im sw

w ord´s ceros de escritura

71%

gr id

63%

84%

m

55% 15%

68%

rl

37%

pe

58%

tu

pl u

eg ij p

si ap

21%

45% 85%

d

75%

47%

42%

rb 3

79%

go

25%

53%

ap

Porcentaje

Gráfica que muestra los word´s ceros y diferentes de ceros de escritura y su promedio

w ord´s diferentes de ceros de escritura

Gráfica 4.7.- Porcentaje de cadenas de word con valor igual a cero y diferente de cero, cuando se tiene un acceso de escritura. Con los valores promedios que se obtuvieron para el caso de lectura y escritura de cadenas de word con valor igual a cero, se deduce que es importante tomar en cuenta el impacto que se tiene en el consumo de energía, al activar el 41% de accesos de lecturas y el 39% de accesos de escrituras que solo contienen datos de 32 bit’s con valor igual a cero, esto quiere decir, que entre mayores sean las detecciones de ceros al dividir el registro, mayor fortaleza tendrá el proponer técnicas que optimicen el uso de registros para poder tener un menor consumo de energía. Ya concluidas las detecciones de cadenas de word con valor igual a cero, se procede a simular las detecciones de cadenas de enteros con valor igual a cero. Para poder obtener datos estadísticos, se modificó el simulador a nivel de programación, y los datos que entregó, se explicarán después de la descripción de la lógica del código correctamente modificado e incorrectamente modificado. En las figuras siguientes, se muestran las maneras incorrectas y correctas de como se hizo el barrido de los bit´s dentro de los registros, para obtener las cadenas de datos; por ejemplo, en la fig.4.8. se muestra dentro de un óvalo un conjunto de 16 bit´s, el cual,

42

Capítulo 4

Optimización del Banco de Registros

representa la forma correcta de entender como se consideró las obtención de cadenas de enteros con valor igual a cero.

Los 16 bits cero están juntos

Int 1 00000000

00000000

Int 2 00000001

01010010

Figura 4.8.- Forma correcta de cómo se obtuvieron las cadenas de enteros con valores iguales a cero dentro de los registros. Mientras que en la fig.4.9 se indica la forma incorrecta de entender como se realizó la obtención de las cadenas de enteros iguales a cero, porque los círculos que encierran dos grupos de 8 bit´s forman una cadena de enteros, pero no se puede considerar como tal debido a la separación que tienen los dos conjuntos de bit´s. Los 16 bits cero no están juntos

Int 1 00000000

00000101

Int 2 00000001

00000000

Figura 4.9.- Forma incorrecta de comprender cómo se obtuvieron las cadenas de enteros con valor igual a cero dentro de los registros. La explicación anterior, de la obtención de cadenas de enteros, es importante, ya que así fue como se consideró dentro de la programación del simulador para la obtención de cadenas de enteros con valor igual a cero. Las simulaciones para tener resultados de los conteos de las cadenas de enteros ceros, que se tienen cuando se lee o se escribe un dato dentro del banco de registros físico, se realizaron con los SPEC95. Los resultados de las diferentes simulaciones, se observan en la gráfica 4.8. Los resultados indican un 54% de cadenas de enteros iguales a cero. La carga de trabajo que utilizo la mayor cantidad de cadenas de enteros con valor igual a cero fue ijpeg con un 71%. Sin embargo la carga de trabajo que tuvo una utilidad mayor en las cadenas de enteros con valor diferente de ceros fue turb3d con un 66%. Los resultados mostraron que la carga de trabajo ijpeg, utilizó mayor cantidad de cadenas de enteros con valor de cero, a diferencia de la utilidad de cadenas de word con valor igual cero, y aun el SPEC turb3d que fue el que menor cantidad de cadenas de enteros ceros utilizó, también mostró en sus resultados que utilizó mayor cantidad de cadenas de enteros, que de word con valor de cero. 43

Capítulo 4

Optimización del Banco de Registros

53%

62%

65%

63%

53%

49%

47%

38%

enteros ceros totales

54%

o ed i

m

pr om

88 k

sim

gr id m

pe

46%

li

51%

rl

47%

pr es s

34%

37%

co m

63%

35%

sw im

66%

tu rb 3d

42%

37%

go

71%

lu

65%

58%

ap p

29%

ijp eg

35%

ap si

porcentaje

Gráfica que muestra a los enteros ceros y diferentes de ceros totales y su promedio

enteros diferentes de ceros totales

Gráfica 4.8.- Porcentaje del uso de las cadenas de enteros (int) con valor igual a cero. Para realizar las pruebas de detección de cadenas de enteros cuando se realiza una lectura, con valor igual y diferente de cero, se tuvo que modificar el simulador con instrucciones básicas de lenguaje C, y los resultados de las simulaciones se aprecian en la gráfica 4.9. La carga de trabajo que utilizó más cadenas de enteros con valor igual a cero fue ijpeg con el 67% y la que tuvo el menor uso de éstas, fue turb3d con un 35%.

48%

39%

46% 54%

io ed om

ks im 88

m

pe

61%

li

63%

52%

pr

54%

gr id

50%

rl

37%

m

co enteros ceros totales

46%

s

65%

50%

pr es

d

35%

rb 3

go

61%

35%

m

65%

sw im

39%

tu

ijp

ap

42%

u

67%

pl

66%

58%

ap

33%

eg

34%

si

porcentaje

Gráfica que muestra los enteros ceros y diferentes de ceros de lectura y su promedio

enteros diferentes de ceros totales

Gráfica 4.9.- Porcentaje del uso de las cadenas de enteros con valor igual a cero y diferente de cero cuando se tiene un acceso de lectura. Aunque turb3d fue un SPEC que utilizó la menor cantidad de cadenas de enteros con valor igual a cero. se puede mencionar que tanto en la carga de trabajo de turb3d como en todas las otras cargas de trabajo se puede tener una optimización del consumo de energía si se aplicaran técnicas de detecciones de ceros con los resultados ya mencionados. La gráfica 4.10, indica los resultados obtenidos en el análisis de las escrituras, asumiendo una granularidad de entero. Como resultado se obtuvo un 49% de cadenas de enteros iguales a cero y la carga de trabajo que utilizo más cadenas con granularidad de entero con valor igual a cero fue ijpeg con el 78%. Sin embargo también se menciona a la carga de trabajo que utilizo la menor cantidad de cadenas de enteros iguales a cero, la cual fue turb3d con un 30%.

44

Capítulo 4

Optimización del Banco de Registros

42%

31%

51% 49%

io ed om

ks im 88 m

m

69%

li

65%

58%

pr

35%

gr id

40% rl

34%

pr es

im

co

sw

d

enteros ceros totales

60%

s

64%

30%

m

66%

66%

pe

36%

70%

rb 3

u pl ap

eg ij p

40%

34%

tu

78%

52%

ap

60%

go

22%

48%

si

porcentaje

Gráfica que muestra los enteros ceros y diferentes de ceros de escritua y su promedio

enteros diferentes de ceros totales

Gráfica 4.10.- Porcentaje del uso de las cadenas de enteros con valor igual a cero y diferente de cero cuando se tiene un acceso de escritura. La gráfica 4.10, indica los resultados obtenidos en el análisis de las escrituras, asumiendo una granularidad de entero. Como resultado se obtuvo un 49% de cadenas de enteros iguales a cero y la carga de trabajo que utilizo más cadenas con granularidad de entero con valor igual a cero fue ijpeg con el 78%. Sin embargo también se menciona a la carga de trabajo que utilizo la menor cantidad de cadenas de enteros iguales a cero, la cual fue turb3d con un 30%. Con los resultados que se obtuvieron, para el caso de detecciones de cadenas de enteros ceros en accesos de lectura al banco de registros, se observó que se tuvo un 13% más de detecciones en comparación con las detecciones de cadenas de word con el mimo valor. También hubo una mayor detección de cadenas de enteros ceros de escritura, ya que los resultados mostraron un 10% más en comparación con las detecciones de cadenas de word cuando se realizan accesos de escritura. Lo cual demuestra que se tienen mayores resultados de detecciones de ceros al aumentar cada vez más las divisiones de cadenas dentro del registro. Como se observó con anterioridad, la detección de cadenas de ceros fue mejor ya que la división de enteros es la mitad de una cadena de word. La siguiente detección se hizo con la división de byte´s, en la que se espera obtener mejores resultados que los anteriores. Para poder obtener los resultados de las cadenas de byte´s con valor igual a cero, se modificó el simulador a nivel de programación, igual que en el caso de word y int, solo que en este caso, se formaron grupos o cadenas de 8 bit´s. En la figura 4.10, se observa la forma correcta de como se realizó la modificación para poder obtener los resultados esperados. Todos los bit´s que se muestran en la figura 4.10, forman el contenido de un registro, pero se encierran en dos grupos (óvalos) de 8 bit´s iguales a cero, los cuales, se contaron de derecha a izquierda para poder formar las cadenas de byte´s con un valor igual a cero, esto quiere decir, que si los 8 primeros bit´s no son todos iguales a cero se descartaran y se continuará contando los siguientes 8 bit´s y si todos son iguales a cero, el simulador lo tomará como si encontrara una cadena de byte´s con valor igual a cero.

45

Capítulo 4

Optimización del Banco de Registros

Los 8 bits cero están juntos

Los 8 bits cero están juntos

Byte 1 0000

0000

Byte 2 1001

0010

Byte 3 0000

0000

Byte 4 0011

1111

Figura 4.10.- Forma correcta de cómo se obtuvieron las cadenas de byte’s con valores iguales a cero, dentro de los registros. Sin embargo, también es importante mencionar, la forma incorrecta de cómo el simulador no considera la obtención de una cadena de byte´s con valor igual a cero. La figura 4.11, señala cuatro círculos que contienen 4 bit´s, los cuales podrían formar cadenas de byte’s si se unieran en forma par, pero el simulador no lo puede considerar como la obtención de una cadena de byte´s con valor igual a cero ya que se encuentran separadas, y la finalidad es que ambos grupos de 4 bit´s estén juntos de derecha a izquierda. Los 8 bit´s cero no están juntos

Byte 1 0000

0100

Byte 2 0000

0010

Byte 3 0000

0010

Byte 4 0011

0000

Figura 4.11.- Forma incorrecta de comprender como se obtuvieron las cadenas de byte’s con valor igual a cero, dentro de los registros. Los resultados obtenidos con las simulaciones realizadas se observan en la gráfica 4.11. En ella, se muestra un 61% de cadenas de byte´s iguales a cero. Con estos resultados, se observa que en promedio se tuvo un incremento del 7% en las detecciones de cadenas de byte´s ceros en comparación con las detecciones de cadenas de enteros con valor igual a cero. La carga de trabajo que utilizó más byte´s iguales a cero fue ijpeg con el 77%. Es importante destacar, que más del 50% byte´s son iguales a cero. Los resultados mostraron que se tuvieron muchas detecciones de byte´s iguales a cero pero para tener un resultado más concreto se obtuvieron los resultados para los byte´s de lectura (gráfica 4.12) y de escritura (gráfica 4.13).

46

Capítulo 4

Optimización del Banco de Registros

49%

39%

68%

62%

61%

68%

57%

51%

61%

io ed om

m

pr

88

ks im

gr id m

s pr es co

byte´s ceros totales

li

43%

rl

32%

im

39%

m

tu

38%

pe

41%

32%

sw

pl ap

ijp

ap

67%

d

49%

59%

rb 3

77%

33%

go

72%

51%

u

23%

eg

28%

si

porcentaje

Gráfica que muestra los byte´s ceros y diferentes de ceros totales y su promedio

byte´s diferentes de ceros totales

Gráfica 4.11.- Porcentaje de byte´s ceros totales y su promedio. La gráfica 4.12, señala los resultados obtenidos en el análisis de las lecturas, asumiendo una granularidad de byte. Los resultados indican que el 62% de cadenas de byte´s fueron iguales a cero. Las cargas de trabajo que más cadenas de byte´s iguales a cero utilizaron a la hora de hacer una lectura, fueron apsi e ijpeg, ambas con un 74%. Como se había observado ijpeg siempre era la carga de trabajo que más cadenas de cero utilizaba, sin embargo, para el caso de byte´s se encontró que apsi también utilizó la misma cantidad de cadenas de byte´s iguales a cero. La carga de trabajo en donde se detecto la menor cantidad de de cadenas de byte´s cero fue turb3d con un 42%. Con los resultados, se puede observar que se incrementó con un 8% las detecciones de cadenas de byte´s con valor igual a cero para el caso de lecturas, en comparación con las detecciones de cadenas de enteros con valor igual a cero que se leen.

48%

38%

68%

64%

63%

68%

57%

52%

62%

io ed om

pr

ks im 88 m

m

pe

co

sw

byte´s ceros totales

li

43%

gr id

32%

rl

37%

s

36%

im

d

42%

rb 3

go

66%

32%

pr es

58%

m

34%

tu

i jp

ap

50%

u

74%

pl

74%

50%

ap

26%

eg

26%

si

porcentaje

Gráfica que muestra los byte´s ceros y diferentes de ceros de lectura y su promedio

byte´s diferentes de ceros totales

Gráfica 4.12.- Porcentaje de byte´s ceros y diferentes de ceros de lecturas, y su promedio. Para el caso de escrituras se tiene la gráfica 4.13. En donde se observa, que el promedio de cadenas de byte´s con valor igual a cero cuando se realiza una escritura fue del 56%. Lo cual, indica que se tuvo un incremento del 7% en las detecciones de cadenas de byte´s ceros en comparación con las detecciones de cadenas de enteros con valor igual a cero cuando se realiza una escritura. La carga de trabajo que utilizó más cadenas de byte´s

47

Capítulo 4

Optimización del Banco de Registros

ceros fue ijpeg con un 83% y la carga de trabajo que utilizó la menor cantidad de cadenas de byte´s fue turb3d con un 39%.

byte´s ceros totales

67%

54%

41%

56%

pr om

m

m

44%

ed io

61%

li

46%

88 ks im

47%

33%

gr id

46%

pe rl

53%

pr es s

go

70%

39%

54%

co m

70%

46%

tu rb 3d

83%

30%

59%

sw im

30%

54%

ap pl u

55%

17%

ijp eg

45%

ap si

porcentaje

Gráfica que muestra los byte´s ceros y diferentes de ceros de escritura y su promedio

byte´s diferentes de ceros totales

Gráfica 4.13.- Porcentaje de byte´s ceros y diferentes de ceros de escritura y su promedio. Con lo obtenido, se mostró que la detección de byte´s iguales a cero fue mucho mayor que en el caso de word y int, con esto, la detección es cada vez mucho mayor. Por último, se tiene la cadena de nibble´s. La cual consiste en agrupar cadenas de 4 bits, esto se realizó de la misma forma que las anteriores cadenas, modificando el simulador para poder conocer todas las cadenas de nibble´s iguales a cero que se utilizan. En las figuras siguientes se indica la forma correcta e incorrecta de como se detectaron todos los nibble´s iguala a cero. En la figura 4.12, se observan círculos con grupos de 4 bit’s, que están unidos, así es la forma correcta de cómo se obtuvieron los nibble´s iguales a cero. Los 4 bits cero están juntos

Los 4 bits cero están juntos

nibble 0000

nibble 0000

nibble 1001

nibble 0010

nibble 0000

nibble 0000

nibble 0011

nibble 1111

Figura 4.12.- Forma correcta de como se obtuvieron las cadenas de nibble’s con valores iguales a cero, dentro de los registros. Sin embargo, la forma incorrecta de entender como se detectaran los nibble cero es como se muestra en la figura 4.13. Los óvalos encierran bits iguales a cero pero no se consideran como nibble´s, ya que no están unidos los grupos de 4 bit´s. Es importante mencionar, que el barrido que se hizo dentro del registro, fue en forma par, es decir, de dos en dos hasta encontrar la unión de nuestra cadena.

48

Capítulo 4

Optimización del Banco de Registros

Los 4 bits cero están juntos

Los 4 bits cero no están juntos

nibble

nibble

nibble

0000

0000

nibble

1001

0010

nibble

nibble 0000

nibble

nibble

0000

0100

0001

Figura 4.13.- Forma incorrecta de comprender cómo se obtuvieron las cadenas de nibble’s con valor igual a cero dentro de los registros. Con las simulaciones se obtuvo la información indicada en la gráfica 4.14. En donde, se observa que el 71% se trataba de cadenas de 4 bit´s iguales a cero. El incremento que se tuvo de las detecciones de cadenas de nibble´s con valor igual a cero con respecto a las cadenas de byte´s con valor igual a cero fue del 10%. La carga de trabajo ijpeg utilizó el 83% de cadenas de nibble´s iguales a cero.

40%

29%

76%

70%

72%

73%

68%

60%

71%

io ed om

pr

ks im 88 m

m

pe

pr es co

nibble´s ceros totales

li

32%

gr id

27%

rl

28%

s

30%

m

rb 3

24%

sw im

57%

d

73%

go

62%

43%

tu

i jp

ap

27%

u

83%

38%

pl

82%

ap

17%

eg

18%

si

porcentaje

Gráfica que muestra los nibble´s ceros y diferentes de ceros totales y su promedio

nibble´s diferentes de ceros totales

Gráfica 4.14.- Porcentaje de nibble’s ceros y diferentes de ceros totales y su promedio. Para el caso de nibble´s de lectura reportado en la gráfica 4.15, se encontró que el 71% de lecturas con granularidad de nibble´s fueron iguales a cero. El incremento que se tuvo de las detecciones de cadenas de nibble´s de lectura con valor igual a cero con respecto a las cadenas de byte´s de lectura con valor igual a cero fue del 9%. La carga de trabajo ijpeg utilizó el 83% de cadenas de nibble´s igual a cero, siendo así, la carga de trabajo que utiliza mas cadenas de word, int, byte´s y nibble´s cero.

49

Capítulo 4

Optimización del Banco de Registros

27%

31%

42%

29%

76%

71%

74%

73%

69%

58%

71%

io ed

m

pr

88

om

ks im

gr id m

s pr es m co

nibble´s ceros totales

li

26%

sw im

pl

29%

rl

61%

24%

pe

72%

d

62%

ap

ij p

ap

39%

tu rb 3

83%

28%

go

81%

38%

u

17%

eg

19%

si

porcentaje

Gráfica que muestra los nibble´s ceros y diferentes de ceros de lectura y su promedio

nibble´s diferentes de ceros totales

Gráfica 4.15.- Porcentaje de nibble´s ceros y diferentes de ceros de lecturas y su promedio. Para el caso de escrituras se muestra la gráfica 4.16, y nuestros resultados indican que el 66% fueron cadenas de nibble´s iguales a cero. La carga de trabajo que utilizó la mayor cantidad de cadenas de nibble´s iguales a cero fue ijpeg con un 87%.

34%

57%

63%

72%

65%

55%

66%

om

m

pe

li pr

m

co

ed io

45%

88 ks im

35%

gr id

28%

rl

37%

pr es

im sw

rb 3 tu

nibble´s ceros totales

43%

s

77%

49%

m

74%

23%

51%

d

61%

go

eg i jp

ap

26%

lu

87%

64%

39%

ap p

13%

36%

si

porcentaje

Gráfica que muestra los nibble´s ceros y diferentes de ceros de escritura y su promedio

nibble´s diferentes de ceros totales

Gráfica 4.16.- Porcentaje de nibble´s ceros y diferentes de ceros de escrituras y su promedio. Con los resultados que se obtuvieron, se observó un incremento del 10% al detectar cadenas de nibble’s con valor igual cero, en comparación con las cadenas de byte´s, este resultado se mostró mucho mejor que el entregado por las cadenas de word, int y byte´s, y la carga de trabajo que tuvo en sus resultados la mejor utilidad de cadenas con valor igual a cero fue ijpeg, tanto en lecturas como en escrituras, lo cual indica que es la carga de trabajo que más se puede optimizar con detecciones de ceros. Con lo observado en este capítulo, se mostró que todas las cadenas iguales a cero que se detectaron fueron aptas para optimizar el banco de registros, basándose en la detección de ceros. La gráfica 4.17, indica una reseña general de todas las cadenas expuestas en las gráficas anteriores, donde se muestra que en promedio se puede optimizar el banco de registros hasta un 55%, independientemente del tamaño de la cadena seleccionada. 50

Capítulo 4

Optimización del Banco de Registros Gráfica que muestra los % de las cadenas iguales a cero y su promedio 71% 62%

porcentaje

54% 41%

39%

word de lectura

word de escritura

int de lectura

66%

56%

55%

49%

int de escritura

byte de lectura

byte de escritura

nibble de lectura

nibble de escritura

promedio

Gráfica 4.17.- Resumen de los porcentajes de las cadenas iguales a cero para los accesos de lectura y escritura, al banco de registros.

51

Capítulo 5

Modelos Propuestos

5 CAPÍTULO

Modelos Propuestos para la Optimización del Rendimiento en el Banco de Registros Físicos con un Impacto en el Consumo de Energía

Resumen: Basándose en los resultados obtenidos de las disquisiciones experimentales realizadas en el capitulo anterior, se propusieron técnicas que optimizan el acceso al banco de registros mediante detecciones de cadenas de word, int, byte y nibble, que tenían un valor igual a cero. Dado que al leer y escribir dichas cadenas de datos se realiza un consumo de energía, se proponen técnicas de ahorro de lecturas y escrituras tanto al banco de registros como a algunos bit’s contenidos dentro del registro. La primera técnica consiste en leer y escribir un solo bit por cada cadena con valor igual a cero, en lugar de leer todos los bit’s de las cadenas, la cual se nombro como Detección de Ceros utilizando un bit de Bandera (DCbB) y se explica más adelante. La segunda técnica es muy similar a la primera ya que también se basó en la detección de cadenas de ceros, sin embargo, la diferencia que tiene con respecto a la primera técnica, es que esta no contiene un bit de bandera, sino una tabla de mapeo que indica el contenido de las cadenas y se le llamo Detección de Ceros utilizando una Tabla de Mapeo (DCTM), la cual se explica más adelante.

52

Capítulo 5

Modelos Propuestos

5.1 Modelo de Detección de Ceros utilizando un bit de Bandera (DCbB). El modelo DCbB consiste en anexar un bit de bandera a cada registro, el cual puede recibir dos valores (1 y 0). Cuando entrega un uno se considera que se detecto una cadena con valor igual a cero, esto quiere decir que se descarta la lectura del contenido de la cadena ya que solo contiene bit´s con valor igual a cero y si el bit de bandera entrega un cero, se considera que se tiene una cadena con un valor diferente de cero, lo cual indica que se tiene que leer el bit de bandera más el contenido de la cadena. Para poder realizar la lectura del bit de bandera, se tuvo que penalizar con un ciclo de más, dentro de la etapa de decodificación. El incremento del ciclo se muestra en la figura 5.1, en donde, se hace mención al fuerte impacto en el tiempo de ejecución, ya que en el primer ciclo se tuvo la lectura del bit de bandera, el cual indicó el estatus en que se encontraba la cadena, y si éste fuera igual a uno, solo se leía el bit de bandera, ocupándose el primer ciclo de reloj, pero de lo contrario, cuando el estatus del bit era igual a cero, esto indicaba que se tenia el primer ciclo de la arquitectura más el ciclo aumentado para leer el contenido de la cadena de ceros. Etapa en donde se aumentó un ciclo. Búsqueda

Decodificación

Lanzamiento

Ejecución

Postescritura

Unidades funcionales

Cache de datos

Retiro de instrucciones

Banco de Registros

Cache de instrucciones

Renombra y Decodifica

Ventana de instrucciones

Interfaz de memoria

Lectura del Lectura de bit 1C contenido 2C

Reordenamiento y asignación

Figura 5.1.- Muestra la etapa en donde se aumentó un ciclo dentro de la arquitectura convencional de un procesador.

53

Capítulo 5

Modelos Propuestos

En la figura 5.2, se muestra de forma gráfica la técnica DCbB incorporada a la arquitectura, en donde se anexo el bit de bandera a todas las cadenas de word, int, byte y nibble dentro de los registros físicos. En ella, se observan diferentes ejemplos del contenido de las cadenas, los cuales son representados con 1 y 0 dentro del bit de bandera. Bit de bandera

N R1 I B R2 B L E

1 0000

1 0000

1

0000 1 0000

0 1110

0 0111

0

0110

0 1110 1

R64 1 0000 1 0000

1

0000

1 00000000

1

00000000

1 00000000

1 00000000

0 11110000

0

11110000

1 00000000

1 00000000

R64 0 1 1 1 1 1 1 1 1

0

11111111

0

0 11111111

R1 B Y R2 T E Tabla de mapeo

Banco de registros

WI Despacho y Renombramiento

ALU

1 0000

1 0000

1 0000

1 0000

0000 1 0000

1 0000

1 0000

1 0000 1 0000 1 0000

1 0000

1 0000

11111111

R1

1

0000000000000000

1

000000000000000

I R2 N T

0

1111111111111111

1

000000000000000

R64 0

1111111111111111

0

1111111111111111

R1

1

0000000000000000000000000000000

W R2 1 O R D R64 0

0000000000000000000000000000000

11111111111111111000000000000000

Figura 5.2- Muestra la técnica DCbB para las cadenas de word, int, byte y nibble. Para implementar el modelo DCbB, se realizaron modificaciones a nivel de programación dentro del simulador simplescalar. Esto se realizó primeramente con una condición de código en “C”, para utilizar el ciclo de más o no utilizarlo, y también se incrementó con un ciclo de más a las unidades funcionales, para realizar la lectura del bit de bandera que pertenece a las cadenas de ceros. Una vez incorporado el modelo DCbB dentro del simulador, se realizaron diferentes simulaciones con todas las cadenas de word, int, byte y nibble., esto nos entrego primeramente cadenas de word de 33 bit´s, ver figura 5.3, para el caso de int quedaron cadenas de 17 bit´s, ver figura 5.4, para el caso de byte´s fueron cadenas de 9 bit´s, ver figura 5.5 y para el caso de nibble´s se tuvieron cadenas de 5 bit´s, ver figura 5.6. Es importante mencionar que al agregar un bit de bandera, se tuvo un aumento en la cantidad de transistores usados en las cadenas mencionadas, lo cual supone un mayor consumo de energía y a su vez un decremento del rendimiento; pero dado que se leen menos bit’s, se espera demostrar que finalmente esto es al contrario.

54

Capítulo 5

Modelos Propuestos

Es importante aclarar, que a nivel de transistores aumenta el número de bit´s dentro de la arquitectura, lo cual es significativo en términos de consumo de potencia, dado que el material semiconductor utilizado es insignificante para poder realizar esta técnica.

Cadena de word con 33 bit´s.

1

00000000000000000000000000000000

Figura 5.3.- Muestra la representación esquemática de la división en palabras (word’s), con su bit de bandera. La primera simulación que se realizó, fue para el caso de cadenas de word de lectura y escritura, donde los resultados que se obtuvieron se muestran en la gráfica 5.1. La cual, muestra que se reduciría en un 52% en promedio las lecturas con granularidad de word y la carga de trabajo que podría reducir en un 77% las lecturas de cadenas de word fue ijpeg, sin embargo, también se menciona la carga de trabajo que menor cantidad de lecturas tuvo en comparación con todas las cargas de trabajo, la cual fue turb3d con un 39%.

32%

52%47%

pr

om

ed

io

li im m

88 ks

gr m

co word´s de lectura

42% 49%48% 40%

id

56%54% 52%

m

pr e

ss

im

28%

45%40% 48%47%

sw

b3 d

39%

pe rl

69% 62%

tu r

ap pl

eg ijp

u

50%46%

46% 44%

go

77%72%

ap si

porcentaje

Gráfica comparativa de specs para word de lecturas y escrituras con el bit de bandera y su promedio.

word´s de escritura

Gráfica 5.1.- Porcentajes de la reducción de cadenas word’s para el caso de lecturas y escrituras con la técnica del bit de bandera (DCbB). Con los resultados de la gráfica 5.1 se pudo observa que al aplicar el modelo DCbB para el caso de word, se mejoró el acceso de lecturas y escrituras de la cadena de word, con un poco más del 50%, esto a su vez, deriva en un ahorro de consumo de energía favorable y no obstante que aunque hubo un incremento de hardware, la técnica fue óptima en cuanto a la reducción de lecturas y escrituras al banco de registros para el caso de cadenas de word.

55

Capítulo 5

Modelos Propuestos

Ahora bien, para el caso de int los resultados que se obtuvieron se indican en la gráfica 5.2, la cual, muestra el ahorro de lecturas y escrituras que se tendría para el caso de cadenas de enteros. Registro de 32 bits dividido en dos int.

00000000000000

1

11111111111111

0

Figura 5.4.- Muestra la división en int de un registro, con su bit de bandera. En la gráfica 5.2, se puede observar que se podría obtener una reducción del 55% en promedio para el caso de lecturas con granularidad de enteros. La carga de trabajo que obtuvo mayor reducción de lecturas de bit´s para cadenas de enteros es ijpeg, con un 78% y la carga de trabajo que tuvo la menor reducción de lecturas fue turb3d con un 40%. Cabe señalar que los resultados obtenidos con las cadenas de enteros fueron un 3% mejores a los obtenidos cuando se utilizaron cadenas de 32 bits (word’s). También, la gráfica 5.2 muestra una disminución del 50% en promedio de escrituras, cuando se trata de cadenas de enteros y la carga de trabajo que lograría tener la mayor reducción de escrituras en el caso de cadenas de enteros sería ijpeg, con un 74%. La carga de trabajo que tuvo la menor reducción de escrituras para el caso de cadenas de enteros fue turb3d con un 30%. Con los resultados que se obtuvieron en la reducción de escrituras, en promedio y para el caso de cadenas de enteros, se puede mencionar que se tuvo un 3% (igual que en las lecturas) de mejoría en comparación con las reducciones de escrituras para el caso de cadenas de word.

om

ed

io

li pr

im m

co

int´s de lectura

88 ks

m

m

pe

gr id

ss

rl

58%55% 55%50% 58%56% 57% 55%50% 45% 45%41%

pr e

47%45%

sw

rb 3

d

40% 30%

im

70%64%

tu

ap

eg ijp

ap

pl u

53%48%

48%46%

go

78%74%

si

porcentaje

Gráfica comparativa de specs para enteros de lectura y escritura con el bit de bandera y su promedio

int´s de escritura

Gráfica 5.2.- Porcentajes de cadenas de int’s para el caso de lecturas y escrituras con el bit de bandera y su promedio. Con los resultados obtenidos, se observó que se pudo optimizar el banco de registros físico, un poco más del 50%, lo cual representa un ahorro de energía considerable.

56

Capítulo 5

Modelos Propuestos

Para el caso de byte, los resultados que se obtuvieron de las simulaciones realizadas para la lectura y escritura, se muestran en la gráfica 5.3. Registro de 32 bits dividido en cuatro byte.

1

1

00000000

00000000

1

00000000

0

00000000

Figura 5.5.- Muestra la división en byte’s de un registro, con su bit de bandera. La gráfica 5.3 revela que se obtuvo una reducción del 57%, en promedio, en las lecturas con granularidad de byte, y la carga de trabajo que presentó la mayor reducción fue ijpeg, con un 77%. Sin embargo, también se hace mención a la carga de trabajo que tendría la menor reducción de lecturas, fue turb3d con un 42%. Con los resultados que se obtuvieron en el caso de las cadenas de byte de lecturas, se tuvo solo un 2% en promedio de mejoría en comparación con las cadenas de enteros de lectura. Para el caso de las escrituras, la gráfica 5.3 muestra que se puede reducir en un 52% en promedio las escrituras que se harían cuando se aplicó la técnica de DCbB, para el caso de cadenas de byte, y la carga de trabajo que más reducciones de escrituras obtuvo, fue ijpeg con un 75%; por lo tanto, la carga de trabajo que tuvo como resultado la menor reducción fue turb3d con un 37%. El promedio de las reducciones de escrituras para el caso de cadenas de byte fue del 2% mejor en comparación con las escrituras de cadenas de enteros.

byte´s de lectura

li

ed io pr om

88 ks im m

m

gr id

59%57% 56%51% 58%57% 59% 50%44% 57%52% 48%

pr es s co m

sw im

42%37% 48%46%

pe rl

71%66%

tu rb 3d

54%48%

ap pl u

ijp eg

50%48%

go

77%75%

ap si

porcentaje

Gráfica comparativa de specs para byte de lectura y escritura con el bit de bandera y su promedio

byte´s de escritura

Gráfica 5.3.- Porcentajes de byte’s de lecturas y escrituras con el bit de bandera y su promedio. Como se observó, los resultados indicaron que para el caso de byte´s, se podría optimizar el banco de registros con el 50% de ahorro de consumo de energía. La técnica al ser aplicada para este caso, demostró lo que se esperaba, es decir, a medida que vamos reduciendo el tamaño de la cadena los resultados son mejores.

57

Capítulo 5

Modelos Propuestos

Por último, se tuvo el caso de nibble, en donde los resultados obtenidos de las simulaciones, se muestran a continuación. Registro de 32 bits dividido en ocho nibble. 1 0000

1

1

0000

0000

1

1 0000

0000

0

1110

1010

0

1

0000

Figura 5.6.- Muestra la división en nibble’s de un registro, con su bit de bandera. La gráfica 5.4 muestra que se consiguió tener una reducción del 54%, en promedio, para el caso de lecturas con granularidad de nibble, y la carga de trabajo que obtuvo mayor reducción de lecturas fue ijpeg, con un 70%; la carga de trabajo que tuvo la menor reducción fue turb3d con un 44%. Con el resultado obtenido de la reducción de lectura de nibble, se tuvo un decremento del 3% en comparación con el resultado de la disminución de cadenas de byte´s. Para el caso de las escrituras, la gráfica 5.4 muestra que se puede reducir en un 49%, en promedio, las escrituras que se harían al aplicar la técnica de DCbB para el caso de cadenas de nibble y siendo ijpeg la carga de trabajo que más reducciones de escrituras obtendría con un 68%, y la que menor reducción obtuvo fue turb3d con un 38%. El promedio que se tuvo de las reducciones de escrituras para el caso de cadenas de nibble, mostró un decremento del 3% en comparación con el resultado de la disminución de cadenas de byte´s de escritura. Gráfica comarativa de specs para nibble´s de lectura y escritura con el bit de bandera y su promedio

nibble´s de lectura

m

ed io

49% 46% 54% 49%

li

58% 55%

pr om

46%

88 ks im

gr id

57%

m

pe rl

38%

55% 49% 46% 52% 48% 48%

pr es s

tu rb 3d

44%

co m

58%

sw im

63% 47%

go

53%

ap pl u

ij p eg

45% 42%

ap si

porcentaje

70% 68%

nibble´s de escritura

Gráfica 5.4.- Porcentajes de nibble´s de lecturas y escrituras con el bit de bandera y su promedio. Con los resultados obtenidos, se mostró que se podría optimizar el número de escrituras y lecturas que se hacen al banco de registros casi un 50%, lo cual representaría un ahorro del consumo de energía respecto al consumo tradicional realizado dentro del banco de registros.

58

Capítulo 5

Modelos Propuestos

Como se pudo observar en todos los casos de word, int, byte y nibble, se obtuvo casi el 50% de optimización del número de accesos de lectura y escritura que se hacen al banco de registros, lo cual, se reflejaría en la mitad del ahorro de energía que ocupa normalmente el banco de registros dentro del procesador. Con lo mencionado, se demostró que la primera técnica fue óptima, ya que con un solo bit que sustituyó a todas las cadenas de ceros, se podría lograr obtener un ahorro de consumo de energía considerable. Pero siempre hubo una diferencia entre todos los tamaños de cadenas que se evaluaron, para ello, en la gráfica 20 se muestra la diferencia de optimización que tuvieron.

Gráfica que muestra la optimización de nibble, byte, int y word de lecturas y escrituras con la técnica DCbB 49%

57%

52%

55%

50%

52%

47%

po rcentaje

54%

nibble

byte

int Lectura

word

Escritura

Gráfica 5.5.- Comparación entre los promedios de las distintas granularidades analizadas nibble’s, byte’s, int’s y word’s en lecturas y escrituras. Al observar la gráfica 5.5, se muestra que para las lecturas, las cadena de ceros que más se pudo optimizar fue la de byte´s con un 57% de ahorro de consumo de energía y la carga de trabajo que más se optimizó según su comportamiento en los casos de word, int y byte y nibble fue ijpeg. Para el caso de las escrituras, se muestra en la gráfica que la cadena de ceros que más se pudo optimizar fue byte con un 52% de ahorro de consumo de energía y la carga de trabajo que más se optimizó fue ijpeg en los casos de word, int, byte y nibble de escritura. Como ya se mencionó, todos los resultados de las lecturas y escrituras fueron para las diferentes cadenas de ceros. Ahora en la gráfica 5.6, se muestra un promedio que representa la mejora que se tuvo en las lecturas y escrituras de todas las cadenas. En el caso de lecturas, se observa que se tuvo un promedio del 55% de detecciones de todas las cadenas con valor igual a cero y para el caso de escrituras, se tuvo un 50% de detecciones de todas las cadenas iguales a cero. Los resultados indicaron que la primera técnica mejoró más cuando se leía un dato que cuando se escribía, pero para los dos casos se podría tener un ahorro del consumo de energía de casi un 50%.

59

Capítulo 5

Modelos Propuestos

Gráfica que muestra la diferencia en porcentajes de lecturas y escrituras

p orcentaje

55%

50%

Lectura

Escritura

Gráfica 5.6.- Muestra la diferencia en porcentajes de lecturas y escrituras iguales a ceros. Es importante mencionar, que nuestra técnica DCbB tiene un impacto negativo en rendimiento, ya que penalizamos con un ciclo cada acceso al banco de registros. En la gráfica 5.7, se muestra que el rendimiento fue penalizado con un 5%, por el ciclo que se tuvo que incrementar para poder leer el bit de bandera. Con esto, se demostró que el impacto en el rendimiento fue mínimo en relación al ahorro de energía que puede obtenerse al aplicar nuestra técnica. Se presenta como una alternativa para implementarse en sistemas en donde el rendimiento no sea el factor importante como es el caso de algunas aplicaciones de los sistemas embebidos y SoC. Gráfica que muestra en porcentajes los ciclos normales en comparación con el adicionado de la tecnica DCbB

porcentaje

100%

95%

Número de ciclos sin alterar

Número de ciclos más el ciclo adicionado

Gráfica 5.7.-Muestra el porcentaje en comparación del ciclo que se adicionó para poder realizar la técnica DCbB, con respecto a los ciclos originales que contiene una arquitectura sin modificar. Como se observó en este modelo, la mejora en el consumo de potencia derivó en una disminución en el rendimiento, al utilizarse en algunos casos un ciclo de reloj extra de penalización. En la siguiente sección se presenta un modelo que evita incrementar el ciclo de reloj, aunque la forma de trabajo es muy similar, ya que también se baso en la detección de cadenas de ceros, pero a diferencia de la primera técnica, es que esta no contiene un bit de bandera, sino una tabla de mapeo que detectará las cadenas con valor igual a cero. A continuación se explicará mas a detalle el segundo modelo llamado Detección de Ceros utilizando una Tabla de Mapeo (DCTM).

60

Capítulo 5

Modelos Propuestos

5.2 Modelo de Detección de Ceros utilizando una Tabla de Mapeo (DCTM). El modelo DCTM, se muestra en figura 5.7, el cual se compone de una tabla de mapeo, la cual se anexó en la etapa de decodificación; con la finalidad de conocer el contenido del registro, y al mismo tiempo poder aprovechar el ciclo de reloj que le pertenece a dicha etapa. El aprovechamiento del ciclo es fundamental, ya que con éste se busca tener un ahorro del consumo de energía con la técnica de detección de ceros, sin afectar al rendimiento. Búsqueda

Decodificación

Lanzamiento

Ejecución

Postescritura

Unidades funcionales

Cache de datos

Retiro de instrucciones

Banco de Registros Cache de instrucciones

Renombra y decodifica

Detector de ceros

Ventana de instrucciones

Interfaz de memoria

Reordenamiento y asignación Tabla de detección de ceros

Figura 5.7.- Muestra la etapa en donde se colocó el detector de ceros. El modelo DCTM, consiste en detectar cadenas de word, int, byte y nibble con valor igual y diferente de cero mediante una tabla de mapeo, como se muestra en la figura 5.8. Cuando se detectan cadenas con valor igual a cero se coloca un bit con valor igual a uno dentro de la tabla de mapeo, la cual, indica que el contenido de la cadena es igual a cero, de la misma forma, se hace cuando las cadenas de int, byte y nibble contienen valores iguales a cero. También, cuando se detectan valores diferentes de cero dentro de las cadenas de int, byte y nibble se coloca un bit con valor igual a cero dentro de la tabla de mapeo. Cuando los bit´s contenidos dentro de la tabla de mapeo son iguales a 0 se bloquea el proceso de lectura y escritura al banco de registros. Cuando la tabla de mapeo contiene bit´s iguales a 1 se procede al proceso de lectura/escritura normal. Es importante mencionar que el modelo DCTM se implementó dentro del simulador simplescalar con la finalidad de adquirir resultados estadísticos. Como se sabe, el simulador esta creado con el lenguaje de programación de “C”, y la creación de la tabla de mapeo de detección de ceros para las diferentes cadenas se hizo a partir de dicho lenguaje dentro del simulador.

61

Capítulo 5

Modelos Propuestos

Para el caso de cadenas de word se muestra la figura 5.9, en donde se observa que se conoce el contenido de la cadena y se coloca dentro de la tabla de mapeo un bit con valor igual a 1, si la cadena es igual a cero, sin embargo, también se le puede asignar un valor igual a cero al bit si la cadena contiene un valor diferente de cero.

Tabla de mapeo N I B B L E B Y T E

I N T

R1 0000 0000 0111 1111 0000 0000 0011 1000

R1

1

R64 0000 0000 0111 1111 0000 0000 0011 1000

R64

1

R1

R1

1

R64

1

1

0

1

0

0

1

0

1

1

0

1

0

0

4bit´s / 8cadenas

00000000

01111111

00000000

00111000

0

1

0

1

0 0

8bit´s / 4cadenas R64 00000000 R1

01111111

00000000000000000

00000000

00111000

0000000000111000

R1

1

R64

1

0 0

16bit´s / 2cadenas R64

W O R D

Detector de Cero

R1

0000000000000000

0000000000111000

000000000000000000000000000000000

0

R1

1

R64

0

32bit´s / 1cadena R64

00000000000000000000000000111000

Banco de Registros

Despacho y Renombramiento

Estación de Reserva

Unidades Funcionales

Figura 5.8.- Muestra la lectura anticipada de los datos contenidos dentro de los registros, para conocer si sus valores son iguales o diferentes de ceros.

62

Capítulo 5

Modelos Propuestos

4 bit´s = 8 nibble´s

8 bit´s = 4 byte´s

16 bit´s = 2 int´s

32 bit´s = 1 word

Por cada bit hay

N I B B L E B Y T E

I N T

W O R D

R1 0000 0000 0111 1111 0000 0000 0011 1000

Bit´s de línea central R64 0000 0000 0111 1111 0000 0000 0011 1000 R1

00000000

01111111

00000000

00111000

R64 00000000

01111111

00000000

00111000

R1

00000000000000000

0000000000111000

R64

0000000000000000

0000000000111000

R1

000000000000000000000000000000000

R64

00000000000000000000000000111000

VDD

Núcleo de Registros

Precarga Amplificadores

BIT Bit de tabla

BIT

Figura 5.9.- Proceso de construcción del dato que se lee del Banco de Registros. Los resultados obtenidos por las simulaciones, para el caso de cadenas de word, se muestran en la gráfica 5.8. Se observa que se tuvo una reducción en promedio del 48% de lecturas de bit´s con valor igual a cero, cuando se tenían cadenas con granularidad de word. La carga de trabajo que tuvo la mayor reducción de lecturas de bit´s iguales a cero para el caso de cadenas de word fue ijpeg con un 66%, y la carga de trabajo que tuvo la menor reducción de bit´s iguales a cero asumiendo cadenas de word fue turb3d con un 15%. Cuando se realizaron escrituras al banco de registros, se observó que se obtuvo en promedio un 40% de reducciones de escrituras de bit´s con valor igual a cero para el caso de cadenas de word. La carga de trabajo que tuvo más reducciones de escrituras de bit´s con valor igual a cero, para el caso de word, fue ijpeg con un 75% y la carga de trabajo que redujo la menor cantidad de escrituras de bit´s iguales a cero para el caso de word fue turb3d con un 11%.

62%

54%

48% 23%

40%

16% 15%

ed io

27%

m

pr es s co m

sw im

d tu rb 3

go

pl u ap

ij p eg

pe rl

16%

word´s de lectura

63% 41%

35% 15% 11%

57%

li

64%

53% 57% 57% 48%

pr om

48%

75%

88 ks im

66%

m gr id

57%

ap si

porcentaje

Grafica comparativa de specs para cadenas de word de lecturas y escrituras con la técnica DCTM

word´s de escritura

Gráfica 5.8.- Gráfica que muestra la optimización que se tuvo con la técnica DCTM para las cadenas de word’s que leen y se escriben. 63

Capítulo 5

Modelos Propuestos

Como se observó en los resultados, se podría optimizar el rendimiento del banco de registros; reduciendo hasta un promedio del 48% las lecturas de bit´s con valor igual a cero cuando se asumen cadenas de word, y el mismo porcentaje se podría reflejar en un ahorro del consumo de energía igual o por lo menos similar. También se tendría una optimización al reducir las escrituras de bit´s iguales a cero con un 40% para el caso de cadenas con granularidad de word y el mismo porcentaje, tendría un impacto proporcional en el ahorro del consumo de energía. Para el caso de int se muestra la figura 5.9, en donde se observa que se conoce el contenido de la cadena y se coloca dentro de la tabla de mapeo un bit con valor igual a 1 si la cadena es igual a cero o con un 0 si la cadena contiene un dato diferente de cero. Para comprobar la validez que tiene la técnica DCTM para el caso de cadenas de enteros, se realizaron las simulaciones correspondientes. Los resultados obtenidos se muestran en la gráfica 5.9. En donde se observa que se tuvo una reducción en promedio de lecturas de bit´s con valor igual a cero del 59% para el caso de cadenas de enteros, lo cual, se reflejaría en un ahorro del consumo de energía del mismo, ya que este porcentaje sólo representa la activación de 6 transistores que contiene solamente un bit, en lugar de activar los 16 bit´s contenidos dentro de la cadena de enteros. Con los resultados obtenidos, se puede mencionar que se tuvo en promedio un incremento del 11% en las reducciones de lecturas de bit´s iguales a cero para el caso de enteros, en comparación con las reducciones que se obtuvieron en el caso de cadenas de word, por lo tanto, se puede mencionar que para el caso de enteros el modelo propuesto es mas eficiente. La carga de trabajo que logró como resultado la mayor reducción de lecturas de bit´s iguales a ceros cuando se asumían cadenas con granularidad de enteros fue ijpeg con un 78%, y la carga de trabajo que obtuvo la menor reducción de lecturas de bit´s ceros cuando se asumían cadenas de enteros fue turb3d con un 28%. Para el caso de escrituras se observó que se obtuvo en promedio un 59% de reducciones de escrituras de bit´s con valor igual a cero para el caso de cadenas de enteros y el mismo porcentaje se podría reflejar en un ahorro del consumo de energía. Con los resultados se puede mencionar que se tuvo en promedio un incremento del 19% en las reducciones de escrituras de bit´s iguales a cero para el caso de cadenas de enteros en comparación con las reducciones que se obtuvieron en el caso de cadenas de word. La carga de trabajo que redujo la mayor cantidad de escrituras de bits´s con valor igual a cero, asumiendo cadenas de enteros, fue ijpeg con un 77% y la carga de trabajo que obtuvo la menor reducción de escrituras de bit´s iguales a cero fue turb3d con un 27%, para el caso de cadenas de enteros.

64

Capítulo 5

Modelos Propuestos

int´s de lectura

59% 59%

ed io

31%

m

41% 39%

li

53%

pr o

m

pr es s m co

sw im

tu rb 3d

go

ap pl u

eg

63% 65% 39%

34%

28% 27%

ijp

69%

58%

88 ks im

67% 64%

52%

gr id

61% 66% 66%

m

52%

rl

78% 77%

pe

66%

ap si

porcentaje

Gráfica comparativa de specs para cadenas de Int's de lecturas y escrituras con la técnica DCTM

int´s de escritura

Gráfica 5.9.- Gráfica que muestra la optimización en el ahorro de energía para cadenas de int’s, en lecturas y escrituras. Como se observó en los resultados, se podría optimizar el rendimiento del banco de registros; reduciendo hasta un promedio del 59% las lecturas de bit´s con valor igual a cero cuando se asumen cadenas de enteros, y el mismo porcentaje se podría reflejar en un ahorro del consumo de energía igual o por lo menos similar. También se tendría una optimización al reducir las escrituras de bit´s iguales a cero, con un 59% para el caso de cadenas con granularidad de enteros y el mismo porcentaje tendría un impacto proporcional en el ahorro del consumo de energía. El siguiente caso consiste en conocer el contenido de las cadenas de 8 bit´s con granularidad de byte, y la figura 5.9 muestra que dentro de la tabla de mapeo se coloca un bit igual a 1 si la cadena de byte’s contiene un valor igual a cero y también se coloca un bit con valor de 0 si la cadena de byte contiene un valor diferente de cero. Los resultados que se obtuvieron de las simulaciones para el caso de cadenas de byte´s se muestran en la gráfica 5.10. En donde, se observa que se tuvo en promedio una reducción de lecturas de bit´s con valor igual a cero del 66% asumiendo cadenas con granularidad de byte´s, lo cual se puede interpretar como un ahorro del consumo de energía del mismo porcentaje o similar, ya que este porcentaje sólo representa la activación de 6 transistores que contienen solamente un bit, en lugar de activar 8 bit´s contenidos dentro de la cadena de byte. Con los resultados se puede señalar que se tuvo un incremento del 7% en las reducciones de lecturas de bit´s con valor igual a cero, asumiendo cadenas de byte´s, en comparación con las reducciones que se obtuvieron en el caso de cadenas de enteros, por lo tanto, se puede mencionar que para el caso de byte´s el modelo propuesto es mas eficiente. La carga de trabajo que obtuvo como resultado la mayor reducción de lecturas de bit´s iguales a ceros cuando se asumían cadenas con granularidad de byte´s fue ijpeg con un 82% y la carga de trabajo que obtuvo la menor reducción de lecturas de bit´s ceros asumiendo cadenas de byte´s fue turb3d con un 36%. Para el caso de escrituras, se muestra que se tuvo en promedio un 57% de reducciones de escrituras de bit´s con valor igual a cero, para el caso de cadenas de byte´s; 65

Capítulo 5

Modelos Propuestos

y el mismo porcentaje se podría reflejar en un ahorro del consumo de energía. Con los resultados se puede mencionar que se tuvo en promedio un decremento del 2% en las reducciones de escrituras de bit´s iguales a cero, para el caso de cadenas de byte´s, en comparación con las reducciones que se obtuvieron en el caso de cadenas de enteros. La carga de trabajo que redujo la mayor cantidad de escrituras de bits´s con valor igual a cero, asumiendo cadenas de byte´s, fue ijpeg con un 81% y la carga de trabajo que obtuvo la menor reducción de escrituras de bit´s iguales a cero fue turb3d con un 39%, para el caso de cadenas de byte´s.

m

pr es s co m

sw im

d tu rb 3

go

pl u ap

byte´s de lectura

68% 67% 47%

60% 53%

66% 52%

57%

41%

ed io

46%

36% 39%

ij p eg

73%

li

74% 69% 71% 55%

pr om

74%

88 ks im

66% 70%

m gr id

55%

pe rl

82% 81%

74%

ap si

porcentaje

Gráfica comparativa de specs para cadenas de byte's de lecturas y escrituras con la técnica DCTM

byte´s de escritura

Gráfica 5.10.- Gráfica que muestra la optimización en el ahorro de energía para cadenas de byte’s, en lecturas y escrituras. Con lo mencionado anteriormente, se podría optimizar el rendimiento del banco de registros; reduciendo hasta un promedio del 66% las lecturas de bit´s con valor igual a cero, cuando se asumen cadenas de byte´s, y el mismo porcentaje se podría reflejar en un ahorro del consumo de energía igual o por lo menos similar. También se tendría una optimización al reducir las escrituras de bit´s iguales a cero con un 57%, para el caso de cadenas con granularidad de byte´s y el mismo porcentaje tendría un impacto proporcional en el ahorro del consumo de energía. Por último, se tiene el caso de cadenas de nibble´s, el cual se muestra en la figura 5.9. En la figura se observa que en la tabla de mapeo se colocan bit´s con valor de 1 si las cadenas de nibble´s contienen valores de ceros, sin embargo, si las cadenas contienen valores diferentes de ceros se colocan bit´s con valor de 0 dentro de la tabla de mapeo. Los resultados que se obtuvieron de las simulaciones se muestran en la gráfica 26. En la gráfica 5.11, se observa que se obtuvo en promedio una reducción de lecturas de bit´s con valor igual a cero del 74%, asumiendo cadenas con granularidad de nibble´s, lo cual se podría interpretar como un ahorro del consumo de energía, ya que este porcentaje sólo representa la activación de 6 transistores que contienen solamente un bit, en lugar de activar 4 bit´s contenidos dentro de la cadena de nibble. Los resultados obtenidos indican que se tuvo un incremento del 8% en las reducciones de lecturas de bit´s con valor igual a cero, asumiendo cadenas de nibble´s, en comparación con las reducciones que se obtuvieron en el caso de cadenas de byte´s. La 66

Capítulo 5

Modelos Propuestos

carga de trabajo que obtuvo como resultado la mayor reducción de lecturas de bit´s iguales a ceros, cuando se tenían cadenas con granularidad de nibble´s, fue ijpeg con un 86% y la carga de trabajo que obtuvo la menor reducción de lecturas de bit´s ceros asumiendo cadenas de nibble´s fue turb3d con un 51%. Para el caso de escrituras, se muestra que se tuvo en promedio un 66% de reducciones de escrituras de bit´s con valor igual a cero, asumiendo cadenas de nibble´s, y el mismo porcentaje se podría reflejar en un ahorro del consumo de energía. Con los resultados se puede mencionar que se tuvo un promedio mayor del 9% en las reducciones de escrituras de bit´s iguales a cero para el caso de cadenas de nibble´s, en comparación con las reducciones de escrituras que se obtuvieron en el caso de cadenas de byte´s. La carga de trabajo que redujo la mayor cantidad de escrituras de bits´s con valor igual a cero, asumiendo cadenas de nibble´s, fue ijpeg con un 85% y la carga de trabajo que obtuvo la menor reducción de escrituras de bit´s iguales a cero fue turb3d con un 49% asumiendo cadenas de byte´s. Gráfica comparativa de specs para cadenas de Nibble's de lecturas y escrituras con la técnica DCTM 74%

66%

ed io

li

65% 61% 56%

pr om

73% 72% 69%

m

pr es s co m

nibble´s de lectura

63%

gr id

57%

51% 49%

88 ks im

83%

74%

m

81% 76%

sw im

64%

pe rl

83%

tu rb 3d

72% 74%

go

i jp eg

ap si

porcentaje

64%

ap pl u

86% 85%

83%

nibble´s de escritura

Gráfica 5.11.- Gráfica que muestra la optimización en el ahorro de energía para cadenas de nibble’s, en lecturas y escrituras. Como se observó, se podría optimizar el rendimiento del banco de registros; reduciendo hasta un promedio del 74% las lecturas de bit´s con valor igual a cero, cuando se asumen cadenas de nibble´s, y el mismo porcentaje se podría reflejar en un ahorro del consumo de energía igual o por lo menos similar. También se tendría una optimización al reducir las escrituras de bit´s iguales a cero con un 66% para el caso de cadenas con granularidad de nibble´s y el mismo porcentaje tendría un impacto proporcional en el ahorro del consumo de energía. Con los resultados antes mencionados, se observa que se optimizó el banco de registros al reducir las lecturas y escrituras de bit´s con valor igual a cero, con más del 60%, asumiendo cadenas de nibble´s, y el mismo porcentaje o similar se podría interpretar en un ahorro del consumo de energía. Como se pudo observar en todos los casos de word, int, byte y nibble, se optimizó el banco de registros al reducir el número de lecturas y escrituras que se hacen a los bit´s con 67

Capítulo 5

Modelos Propuestos

valor igual a cero y la gráfica 27 muestra la diferencia de optimización que tuvieron los casos. La gráfica 5.12 muestra que las cadenas de nibble´s fueron las que más se optimizaron, ya que se tuvo en promedio una reducción de lecturas del 74% de bit´s con valor igual a cero, cuyo resultado es mucho mayor que el de las cadenas de byte, int y word. Sin embargo, el banco de registros también se optimizó al obtener la mayor reducción de escrituras de bit´s con valor igual a cero, con un 66%, asumiendo cadenas de nibble´s y la carga de trabajo que más se podría optimizar debido a que obtuvo en su comportamiento la mayor reducción de bit´s cero en los diferentes casos de word, int, byte y nibble sería ijpeg. Gráfica que muestra la optimización de lecturas y escrituras para nibble, byte, int y word con la técnica DCTM 66%

66%

59%

57%

59% 48%

porcentaje

74%

nibble

byte

int Lectura

40%

word

Escritura

Gráfica 5.12.-Gráfica que muestra la optimización para las cadenas de word’s, int’s, byte’s y nibble’s con la segunda técnica. Anteriormente se habló del buen comportamiento que tuvieron las técnicas propuestas (DCbB y DCTM) con respecto a las diferentes cadenas de word, int, byte y nibble, sin embargo, la gráfica 5.13 muestra que en promedio la segunda técnica tuvo una optimización del 6% mayor en comparación con la primera técnica. Gráfica que muestra la optimización de la primera y segunda técnica 62% 50%

56%

53%

59%

porcentaje

55%

Lectura

Escritura Primera técnica

Promedio

Segunda técnica

Gráfica 5.13.- Gráfica que muestra la optimización de la técnica DCbB V.S. la técnica DCTM.

68

Conclusiones El estudio y análisis del comportamiento de los accesos de lecturas y escrituras que se hacen al banco de registros, nos condujo a proponer técnicas que mejoren el rendimiento del banco de registros, que a su vez tengan un impacto en la reducción del ahorro del consumo de energía. Los resultados que se obtuvieron de las detecciones de ceros para las diferentes cadenas, cuando se realizaban accesos de lectura al banco de registros, nos mostraron que un 41% de cadenas de 32 bits (word´s) fueron ceros. Para el caso de int´s (16 bits) se tuvo que un 54% de cadenas fueron ceros. Para el caso de byte´s (8 bits) y nibbles (4bits) se obtuvo que un 62% y un 71% de las cadenas fueron ceros respectivamente. En el caso de las escrituras, nuestros resultados mostraron que un 39% de cadenas de word´s fueron cero, 49% de cadenas de int´s fueron ceros, 56% de cadenas de byte´s todos los bits fueron ceros y para el caso de nibble´s el 66% de cadenas fueron ceros. De esta forma, nuestros resultados mostraron que entre mas se divida el registro mayor es la cantidad de detecciones de ceros. Las técnicas propuestas en este trabajo, se centraron a en la detección de ceros ya que el comportamiento que se tiene al realizar accesos de lecturas nos mostró que se obtuvo un 41% de registros con valor igual a cero y para el caso de escrituras se obtuvo un 39% de registros con valor igual a cero, del total de los registros utilizados. Con los resultados ya mencionados, se propuso el dividir el registro en cadenas de word, int, byte y nibble con la finalidad de incrementar la detección de ceros. Con los resultados que se obtuvieron de las detecciones de cadenas de ceros, se plantearon dos técnicas, una de ellas se llamó DCbB, la cual consistió en leer un bit de bandera por cada cadena con valor de cero, sin embargo, se tuvo que penalizar con un ciclo cada lectura de cadenas con valor diferente de cero. La segunda técnica, se le nombro DCTM y su función consistió en indicar el contenido de las cadenas con valor igual y diferente de cero dentro de una tabla de mapeo, esta técnica, además de impactar positivamente en el consumo de energía, no degrada el rendimiento debido a que los cambios propuestos no se encuentran en la ruta crítica del procesador. El modelo DCbB, mostró una reducción de accesos de lecturas del 55% y un 50% en el caso de accesos de escrituras. Sin embargo, el modelo DCTM obtuvo una reducción en accesos de lecturas del 62% y un 56% en el caso de accesos de escrituras, ambos resultados, se reflejarían en un ahorro del consumo de energía. Es importante mencionar, que los dos modelos abren paso para nuevas técnicas de detección de cero, que romperá poco a poco con la balanza entre rendimiento y consumo de energía que es y será un factor fundamental mientras se sigan diseñando procesadores superescalares.

69

Trabajos Futuros Del trabajo que se realizó en esta tesis, se abren líneas de investigación que se pretenden abordar como trabajos futuros. Entre estas líneas destacan las siguientes: • • • •

Implementación de los modelos en circuitos integrados o en dispositivos reconfigurables. Simulación de los modelos a nivel de hardware. Técnicas para mejorar el uso de los recursos hardware, disponibles en cada registro. Aprovechar la información de la técnica DCTM para mejorar el IPC del procesador al evitar la ejecución de operaciones con el número cero.

70

Bibliografía [1]

Standard Performance Evaluation Corporation. Spec95, (1995).

[2]

E. T. a. O. R. André Seznec, Register write specialization register read specialization: a path to complexity-effective wide-issue superscalar processors, (2002), pp. 1-12.

[3]

J. H. T. a. K. Asanovi´c, Energy-Efficient Register Access, (2000), pp. 1-6.

[4]

B. Case, Intel Reveals Pentium Implementation Details, (1994), pp. 9-13.

[5]

J. L. H. David A. Paterson, Computer Organization and Design (The Hardware / Software Interface), (2001).

[6]

V. T. a. M. M. David Brooks, Wattch: a framework for architectural-level power analysis and Optimizations, (2000).

[7]

T. F. Dezso Sima, Peter Kacsuk, Advanced Computer Architectures, (1997).

[8]

G. F. Grohoski, Machine Organization of the IBM RISC system/6000 processor, 34 (1990), pp. 37-58.

[9]

R. R. O. a. R. D. Groves, IBM RISC System/6000 Processor Architecture, 34 (1990), pp. 23-26.

[10]

S. Heo, A Low-Power 32 bit Datapath Design, (2000).

[11]

M. Z. Luis Villa, and Krste Asanovi´c, Dynamic Zero Compression for Cache Energy Reduction, (2003), pp. 1-7.

[12]

S. D. Rajeev Balasubramonian, and David H. Albonesi, Reducing the Complexity of the Register File in Dynamic Superscalar Processors, (2001), pp. 1-12.

[13]

A. J. Smith, Cache Memories, ACM Computing Survey, 14 (1982), pp. 473-530.

[14]

E. L. T. Austin, and D. Ernst, "SimpleScalar: An Infrastructure for Computer System Modeling", 35 (2002), pp. 59-67.

[15]

M. A. Teresa, Técnicas Hardware para Optimizar el Uso de los Registros en Procesadores Superescalares, (2003), pp. 16-70.

[16]

J. H.-C. Tseng, Energy-Efficient Register File Design, (1999), pp. 3-67.

[17]

J. P. Uyemura, CMOS Logic Circuit Dedign, (1999), pp. 153-234.

71

Anexo A

Anexo A Funciones que se agregaron al simulador simplescalar v.3.0 1.

Código fuente que nos permitió realizar los conteos de los registros que se escriben al banco de registros, cuyo valor fue igual y/o diferente de cero, asi como las diferentes granularidades dentro de él.

/*Funcion de nible que se escriben en el banco de registro*/ static void nible_w(unsigned long dato2,int tama) { unsigned long temp5,temp4=0; int i, j=0, a[16], c=0, b=0, d=0, f=0, g=0, h=0, m=0, mu=0; int nible_tab_cero_w=0; /* static double write_access;*/ temp4 = dato2; /*Este for cuenta los primeros 4 bits (primer nible) del menos significativo al mas significativo */ /* write_access++; fprintf (stderr,"Accesos de escritura: %f\n",write_access);*/ for (i=0;i>=4; /*Aqui se desplaza del primer nible al segundo y asi sucesivamente*/ j++; } if (tama == 32) acceso_nible_w[mu][0]++; else acceso_nible_w[mu][1]++; date_cont_tab_w[nible_tab_cero_w]++; c=tama/4; b=0; for (i=0;i=4; /*Aqui se desplaza del primer nible al segundo y asi sucesivamente*/ } if (tama == 32) acceso_nible_r[mu][0]++; else acceso_nible_r[mu][1]++; date_cont_tab_r[nible_tab_cero_r]++; c=tama/4; b=0; for (i=0;i= 4; /*Aqui se desplaza del primer nible al segundo y asi sucesivamente*/ } if (tama == 32) acceso_nible[mu][0]++; else

76

Anexo A acceso_nible[mu][1]++; date_cont_tab[nible_tab_cero]++; c=tama/4; b=0; for (i=0;i