Este artículo no pretende detallar a modo informativo qué va a sacar Intel en el próximo siglo, sino que vamos a intentar dar un paseo por las tecnologías y procesadores que Intel planea sacar en los próximo años, sin entrar en demasiados detalles. Vamos a hablar de cosas como Merced, McKinley, Madison, Deerfield, EPIC, IA64, Predication...

Hablar del futuro de Intel es hablar en 64 bits. Y hablar de 64 bits en Intel es hablar de su arquitectura IA64 (Intel Architecture 64). Actualmente los procesadores de Intel se engloban en la IA32.

Paralelismo explícito

La estrella de la arquitectura IA64 es EPIC (Explicit Paralellism Instruction Code, o algo así). Antes de entrar en otros detalles, veamos un poco en que consiste EPIC. La idea básica, de ahí el nombre, es el paralelismo. Pero no cualquier paralelismo, sino paralelismo explícito. Desde hace mucho tiempo, los microprocesadores ya disponen de técnicas de paralelismo, lo que en inglés se conoce por pipelining. El paralelismo consiste en ejecutar más instrucciones en menos tiempo, aunque las instrucciones sigan tardando lo mismo en ejecutarse, mediante un simple truco, aunque algo difícil de explicar en detalle. Intentémoslo.

Un microprocesador ejecuta instrucciones de código máquina. Estas instrucciones le dicen como tiene que ir modificando diferentes posiciones de memoria, y como debe ir modificando el flujo de ejecución. Se tiende a pensar, erróneamente, que un procesador con un reloj a 200 MHz (200 millones de ciclos por segundo) ejecuta 200 millones de estas operaciones por segundo. Esto no es así, por una sencilla razón. Una instrucción no se ejecuta en un solo ciclo de reloj, salvo alguna rara excepción. De hecho, algunas instrucciones tardan bastantes más ciclos, llegando algunas a necesitar 50 o más ciclos para completarse. En cambio, las más rápidas se ejecutan en tan sólo 3 o 4 ciclos de reloj. Aquí es donde entra el paralelismo para solucionar este problema. Se puede dividir cualquier instrucción en fases más o menos comunes a todas: fetch (carga de la instrucción desde la memoria al procesador), decodificación (identificación de qué instrucción nos hemos encontrado), carga de operandos, operación en sí y escritura de resultados. Este esquema, expresamente simplificado, nos da una idea de las fases que todo microprocesador tiene. Vamos a suponer un microprocesador ideal donde todas las operaciones que se pueden ejecutar en él tardan 15 ciclos, correspondientes a tres ciclos por cada una de las 5 fases que hemos descrito. Si ejecutáramos tres de estas operaciones sin ningún tipo de paralelismo, tardaríamos 45 ciclos, según el siguiente esquema:

instr. 1: 111222333444555
instr. 2:                111222333444555
instr. 3:                               111222333444555

Ahora supongamos que somos capaces de dividir el microprocesador en circuitos separados capaces cada uno de trabajar independientemente y ejecutar cada una de las 5 fases anteriores. Si logramos que sean independientes, cuando la instrucción uno ha acabado ya la fase de fetch y pasa a la decodificación, deja libre el módulo que se encarga del fetch, donde puede ir ya ejecutándose la segunda instrucción. De esta forma, logramos paralelizar las instrucciones.

instr. 1: 111222333444555
instr. 2:    111222333444555
instr. 3:       111222333444555

Resultado: las tres instrucciones, por separado, siguen ejecutándose en el mismo tiempo, pero en conjunto ya no tardan 45 ciclos, sino solo 21 ciclos. Más de un 45% de incremento en el rendimiento. De esta forma es como algunos procesadores muy paralelizados logran ejecutar, en media, más de una instrucción por ciclo de reloj, aunque estas instrucciones tarden, por sí mismas, más de un ciclo en ejecutarse.

En la realidad, como siempre, no todo es tan fácil y hay muchos problemas al diseñar un procesador con paralelismo. Por citar algunos de los problemas más comunes, hay veces que una instrucción no se puede ejecutar ya que requiere un dato que quizás calculaba la operación anterior (cosa muy habitual). Claro, si ante este problema detuviéramos la anterior instrucción, bloquearía el procesador y se acabaría el paralelismo hasta que acabara la primera instrucción y con ella se pudiera reanudar la segunda. Para evitar estos problemas se recurre a cortocircuitos, o lo que es lo mismo, se comunican diferentes fases del microprocesador internamente para pasarse antes los datos. Esto, sin embargo, también nos da otros problemas, ya mucho más complicados, como el encontrarnos con que hay que decidir que datos son los correctos en cada momento. En estos problemas ya no entraremos, y se podrían resumir en que el procesador ha de decidir como paralelizar las instrucciones.

Bien, todo lo que hemos visto sobre el paralelismo involucra única y exclusivamente al microprocesador en sí, y más bien a su diseño. El software que se ejecuta sobre él ignora totalmente si hay paralelismo o no. Esto es el paralelismo implícito.

Por el contrario, Intel implementa una solución que de hecho ya deriva de ideas de principios de los años 80. En el paralelismo explícito, el procesador ya no es el que decide cómo paralelizar las instrucciones, sino que es el compilador del software el que ha empaquetado las instrucciones para que el microprocesador pueda ejecutarlas paralelamente sin tantos problemas. De hecho, esta manera es mucho más eficiente, porque el compilador tiene todo el tiempo del mundo para decidir cómo paralelizar y por supuesto, la lógica que puede aplicar es infinitamente más potente que la que podemos encontrar implementada en cualquier microprocesador. Esto también redunda en una simplificación de la circuitería de control del microprocesador, lo que permite acelerar aún más las instrucciones. Además, queda libre más espacio para incluir aún más registros y hacer los buses internos más anchos, lo que permite ejecutar aún más instrucciones en paralelo.

Predication

El otro gran problema del paralelismo que antes no hemos comentado es la predicción de saltos. Las instrucciones que más "molestan" a un procesador paralelizado son los saltos, instrucciones que hacen saltar de un lugar a otro del código el flujo de ejecución del programa. Hasta ahora los procesadores debían "apostar" sobre unas bases decisionales para elegir que operaciones poner después del salto, porque hasta un determinado momento no se puede saber si hay que saltar o no. Ahora, con el paralelismo explícito, el compilador es el que dice cual es la solución más probable, basado en datos mucho más fiables dado el mayor margen de visión que tiene el compilador sobre el código.

Sin embargo, y pese a la ayuda del compilador, hay que seguir intentando hacer predicciones de las ramas sobre las que no se sabe con seguridad hacia donde irá el flujo de ejecución. Ahí es donde entra Predication, la técnica de predicción de EPIC. Se base de funcionamiento es realmente simple: si no sabes que rama coger... coge las dos. Así, ante un salto, Predication utiliza dos pipelines. Una pipeline es una serie de aquellos módulos que antes comentábamos que eran capaces de ejecutar fases de instrucciones, si un procesador tiene dos pipelines puede ejecutar dos instrucciones en una sola fase en un momento dado, duplicando (otra vez en teoría) el rendimiento. En cada una de estas pipelines, Predication lanza cada uno de los dos flujos resultados de efectuar o no el salto. Al cabo de un momento, cuando ya se sabe el resultado, se anula el pipeline erróneo y el otro continúa como si nada.

Speculation

Otro de los grandes problemas de los microprocesadores modernos es el tiempo de latencia de la memoria RAM. Los procesadores son mucho más rápidos que la memoria, y cuando necesitan algún dato deben esperar a que la memoria se los entregue durante un buen número de ciclos. Para paliar esto existen, por supuesto, las memorias cache, que ofrecen un buen aumento del rendimiento. Aún así, el problema sigue siendo grave. EPIC ofrece una buena solución a este problema: puede anticiparse a los datos que van a pedirle antes de que se los pidan, "especulando" qué le van a pedir, de ahí el nombre. Por supuesto, esto también nos da algunos problemas laterales sobre validez de datos, pero una vez tenidos en cuenta el aumento del rendimiento es realmente notable.

Registros

Los registros de un microprocesador son pequeños almacenes de datos, en los que cabe sólo un número. La mayoría de microprocesadores actuales no incluyen más de 32 registros en total. Pueden parecer algo sin mucha importancia, pero de hecho todas las operaciones suelen hacerse sobre registros, por lo que a mayor número de registros más datos tenemos en el microprocesador y menos hemos de recurrir a la memoria externa. Dado el alto grado de paralelización que ofrece EPIC, se hace necesario incluir un gran número de registros, así que se ha optado por 128 registros de propósito general, 128 de coma flotante y 64 registros de 1 bit de "predicación" (utilizados por el sistema Predication). Los 256 registros generales y de coma flotante son de 64 bits, ya que EPIC es exclusivo de la arquitectura IA64.

Compatibilidad

Merced, el primer microprocesador IA64 de Intel, será el primero de su historia que no utilizará las instrucciones x86 que venimos arrastrando desde los años 70. Sin embargo, no se puede abandonar la compatibilidad, así que Intel ha incluido en el diseño del Merced un traductor de instrucciones IA32 a IA64, de tal forma que el Merced funcionará perfectamente con software antiguo, aunque para mostrar su verdadera potencia necesitará de los sistemas compilados ex profeso para IA64, como los futuros sistemas de 64 bits destinados a esta plataforma.

Compiladores

La propia naturaleza de EPIC pone en manos de los compiladores gran parte de la optimización del código, lo que va ha crear grandes diferencias, realmente notables, de rendimiento entre el mismo código compilado bajo diferentes compiladores. Es de esperar que durante los primeros momentos de existencia de la tecnología EPIC, los compiladores aún no estén perfectamente optimizados, y el hecho de cambiarse de un compilador a una versión superior puede que sea bastante decisivo en el futuro.

Esto mismo afecta también a los depuradores. Con técnicas como Speculation y Predication, los debuggers deberán estar muy bien implementados para permitir a los programadores depurar y optimizar su código.

Futuros microprocesadores

Para acabar, vamos a echar un vistazo a Merced y sus sucesores, todos basados en EPIC, IA64 y todo lo anteriormente comentado:

Merced

• desde 600 MHz
• tecnología de 0.18 micras
• será el primer procesador EPIC
• salida a mediados del 2000

• desde 1 GHz (1000 MHz)
• dos veces más rápido que el Merced
• tecnología de cobre, 0.13 micras
• finales del 2001

• mejora del núcleo del McKinley
• desde 1 GHz
• sobre el 2002

• IA64 para ordenadores domésticos
• año 2003

ÚLTIMA REVISIÓN EN FEBRERO DE 1999