INTEGRANTES:Ramos Ramírez Yaser

Exposición:

Índice de Contenido

Introducción................................................................................................................................4

¿Qué es RISC?..............................................................................................................................5

Principios de Diseño de las Computadores RISC..........................................................................5

Características.............................................................................................................................6

RISC Moderno..............................................................................................................................7

RISC vs CISC..................................................................................................................................8

Conjunto de instrucciones...........................................................................................................8

Instrucciones de carga/almacenamiento.................................................................................8

Instrucciones de desplazamiento.............................................................................................8

Instrucciones Booleanas..........................................................................................................9

Instrucciones aritméticas.........................................................................................................9

Instrucciones de salto/bifurcación...........................................................................................9

Instrucciones diversas..............................................................................................................9

CUADRO COMPARATIVO.......................................................................................................10

MODOS DE DIRECCIONAMIENTO...........................................................................................10

FORMATO DE INSTRUCCIONES..............................................................................................10

Optimización..............................................................................................................................11

Técnica del coloreado de grafos............................................................................................11

Arquitectura...............................................................................................................................12

Arquitecturas CISC.................................................................................................................13

Arquitecturas RISC.................................................................................................................14

Papel de los Compiladores en un Sistema RISC.....................................................................16

Segmentación............................................................................................................................17

Segmentación de Cauce.........................................................................................................19

Ejemplo..................................................................................................................................20

Riesgos de Datos y de Control...............................................................................................20

Procesadores Superescalares....................................................................................................21

Procesamiento de las Instrucciones de Salto.........................................................................28

OpenRISC...................................................................................................................................28

Aplicaciones...............................................................................................................................29

Procesadores ARM.................................................................................................................29

Sun SPARC..............................................................................................................................31

Principales Características.................................................................................................32

MIPS.......................................................................................................................................32

Bibliografía.................................................................................................................................34

Índice de Figuras

Figura 1. Microprocesadores CISC.............................................................................................13Figura 2. Microprocesadores RISC.............................................................................................15Figura 3. Programa de instrucciones en el Intel Pentium IV......................................................18Figura 4. Detalle de la segmentación de instrucciones..............................................................18Figura 5. Arquitectura Harvard..................................................................................................19Figura 6. Cómo se conforma la segmentación de instrucción....................................................20Figura 7. Ejecución de instrucciones en un procesador superescalar........................................22Figura 8. Organización de los procesadores superescalares......................................................22Figura 9. Organización de la microarquitectura de un procesador superescalar.......................23Figura 10. Procesador ARM en una impresora HP.....................................................................31Figura 11. Sun UltraSparc II........................................................................................................32Figura 12. Un microprocesador MIPS R4400 fabricado por Toshiba..........................................33

Computadores RISC

Introducción

A lo largo de la historia de la industria de los ordenadores, la tendencia mayormente adoptada para conseguir un aumento de prestaciones, ha sido el incremento de la complejidad de las instrucciones. Es lo que se ha denominado "computación con conjuntos de instrucciones complejas" o CISC (Complex Instruction Set Computing).

Sin embargo, la tendencia actual, se esfuerza en conseguir procesadores con conjuntos de instrucciones de complejidad reducida o RISC (Reduced Instruction Set Computing). La idea es que un conjunto de instrucciones poco complejas son simples, y por tanto de más rápida ejecución, lo que permite crear un código más "aerodinámico".

Tanto la tecnología CISC como la RISC son acreditadas a IBM, aunque sus antecesores bien pueden ser John vonNeumman (inventor del primer programa de ordenador almacenado, y que promovía la velocidad inherente a conjuntos de instrucciones reducidas), Maurice Wilkes (padre de la microprogramación y de muchos conceptos de los diseños RISC), y Seymour Cray (primeros supercomputadores, empleando principios RISC).

En 1975, IBM inició el desarrollo de un controlador para un sistema de conmutación telefónica, que aunque fue abandonado, sirvió como punto de partida para el desarrollo de una CPU con tecnología ECL, corazón del sistema 801, precursor del IBM PC RT.

Los inicios de la tecnología RISC también surgen en el ambiente académico, ya que en 1980, la Universidad de Berkeley (California), el Dr. David A. Patterson inició un proyecto denominado RISC I, que obtuvo resultados en tan solo 19 meses, seguido por RISC II, SOAR (Smalltalk on a RISC) y SPUR (Symbolic Processing on a RISC). El resultado directo, además de la educación en la ingeniería y los fundamentos del diseño de microprocesadores, fue la creación de una máquina que fuese capaz de mayores velocidades de ejecución a menores velocidades de reloj y que requiriese menores esfuerzos de diseño.

Casi simultáneamente, en la Universidad de Stanford, el Dr. John Hennesy inició también un proyecto de implementación RISC, denominado MIPS, seguido por el sistema MIPS-XMP, enfocados hacia el proceso simbólico, demostrando las capacidades de velocidad de la arquitectura RISC.

Ambos profesores se vieron envueltos rápidamente, en proyectos de productos comerciales, y en concreto, Hennesy fue uno de los fundadores de MIPS Computer Systems, mientras Patterson actuaba de asesor durante el desarrollo del primer SPARC.

Por otro lado, durante las pasadas décadas, el multiproceso, como medida de incrementar drásticamente las prestaciones de los sistemas a un coste razonable, se ha visto reducido al ámbito de los computadores de "alto nivel", en parte debido a los bajos niveles de integración del silicio, y a la falta de software que facilitase la ejecución paralela de las aplicaciones.

Las ventajas de los procesadores RISC, especialmente las ligadas a los sistemas abiertos, los hacen plataformas ideales para explorar los puntos fuertes de los sistemas multiprocesadores.

Sin embargo RISC también tenía sus desventajas. Debido a que una serie de instrucciones son necesarias para completar incluso las tareas más sencillas, el número total de instrucciones para la lectura de la memoria es más grande, y por lo tanto lleva más tiempo. Al mismo tiempo no estaba claro dónde habría o no una ganancia neta en el desempeño debido a esta limitación, y hubo una batalla casi continua en el mundo de la prensa y del diseño sobre los conceptos de RISC.

¿Qué es RISC?

Es un tipo de microprocesador con las siguientes características fundamentales:

1. Instrucciones de tamaños fijos y presentados en un reducido número de formatos.2. Sólo las instrucciones de carga y almacenamiento acceden a la memoria por datos.

Además estos procesadores suelen disponer de muchos registros de propósito general.

El objetivo de diseñar máquinas con esta arquitectura es posibilitar la segmentación y el paralelismo en la ejecución de instrucciones y reducir los accesos a memoria. Las máquinas RISC protagonizan la tendencia actual de construcción de microprocesadores. PowerPC, DEC Alpha, MIPS, ARM; son ejemplos de algunos de ellos.

RISC es una filosofía de diseño de CPU para computadora que está a favor de conjuntos de instrucciones pequeñas y simples que toman menor tiempo para ejecutarse. El tipo de procesador más comúnmente utilizado en equipos de escritorio, el x86, está basado en CISC en lugar de RISC, aunque las versiones más nuevas traducen instrucciones basadas en CISC x86 a instrucciones más simples basadas en RISC para uso interno antes de su ejecución.

La idea fue inspirada por el hecho de que muchas de las características que eran incluidas en los diseños tradicionales de CPU para aumentar la velocidad estaban siendo ignoradas por los programas que eran ejecutados en ellas. Además, la velocidad del procesador en relación con la memoria de la computadora que accedía era cada vez más alta. Esto conllevó la aparición de numerosas técnicas para reducir el procesamiento dentro del CPU, así como de reducir el número total de accesos a memoria.

Principios de Diseño de las Computadores RISC

Resulta un tanto ingenuo querer abarcar completamente los principios de diseño de las máquinas RISC, sin embargo, se intentará presentar de una manera general la filosofía básica de diseño de estas maquinas, teniendo en cuenta que dicha filosofía puede presentar variantes. Es muy importante conocer estos principios básicos, pues de éstos se desprenden algunas características importantes de los sistemas basados en microprocesadores RISC.

En el diseño de una máquina RISC se tienen cinco pasos:

1. Analizar las aplicaciones para encontrar las operaciones clave.2. Diseñar un bus de datos que sea óptimo para las operaciones clave.

3. Diseñar instrucciones que realicen las operaciones clave utilizando el bus de datos.4. Agregar nuevas instrucciones sólo si no hacen más lenta a la máquina.5. Repetir este proceso para otros recursos.

El primer punto se refiere a que el diseñador deberá encontrar qué es lo que hacen en realidad los programas que se pretenden ejecutar. Ya sea que los programas a ejecutar sean del tipo algorítmicos tradicionales, o estén dirigidos a robótica o al diseño asistido por computadora.

La parte medular de cualquier sistema es la que contiene los registros, el ALU y los 'buses' que los conectan. Se debe optimar este circuito para el lenguaje o aplicación en cuestión. El tiempo requerido, (denominado tiempo del ciclo del bus de datos) para extraer los operandos de sus registros, mover los datos a través del ALU y almacenar el resultado de nuevo en un registro, deberá hacerse en el tiempo más corto posible.

El siguiente punto a cubrir es diseñar instrucciones de máquina que hagan un buen uso del bus de datos. Por lo general se necesitan solo unas cuantas instrucciones y modos de direccionamiento; sólo se deben colocar instrucciones adicionales si serán usadas con frecuencia y no reducen el desempeño de las más importantes.

Siempre que aparezca una nueva y atractiva característica, deberá analizarse y ver la forma en que se afecta al ciclo de bus. Si se incrementa el tiempo del ciclo, probablemente no vale la pena tenerla.

Por último, el proceso anterior debe repetirse para otros recursos dentro del sistema, tales como memoria cache, administración de memoria, coprocesadores de punto flotante, etcétera.

Una vez planteadas las características principales de la arquitectura RISC así como la filosofía de su diseño, podríamos extender el análisis y estudio de cada una de las características importantes de las arquitecturas RISC y las implicaciones que estas tienen.

Características

Las características comunes a todos los procesadores RISC, fuente de sus capacidades de altas prestaciones, no es sólo una cuestión de diferencias en el conjunto de instrucciones, puesto que es fundamental resaltar el mejor uso y aprovechamiento de los recursos del silicio, es decir, menor tiempo de diseño y empleo de menor número de transistores, lo que redunda en menor número de errores de diseño y menor tiempo de ejecución para instrucciones individuales., son:

1. Modelo de conjunto de instrucciones Load/Store (Cargar/Almacenar). Sólo las instrucciones Load/Store acceden a memoria; las demás operaciones en un RISC, tienen lugar en su gran conjunto de registros. Ello simplifica el direccionamiento y acorta los tiempos de los ciclos de la CPU, y además facilita la gestión de los fallos de páginas (page faults) en entornos de memoria virtual. Además, permite un elevado nivel de concurrencia a consecuencia de la independencia de las operaciones de Load/Store de la ejecución del resto de las instrucciones.

2. Arquitectura no destructiva de tres direcciones. Los procesadores CISC destruyen la información que existe en alguno de los registros, como consecuencia de la ejecución normal de instrucciones; esto es debido a su arquitectura de dos direcciones, por la cual el resultado de una operación sobrescribe uno de los registros que contenía a los operandos.

Por contra, las instrucciones RISC, con tres direcciones, contienen los campos de los dos operandos y de su resultado. Por lo tanto, tanto los operandos origen como el destino, son mantenidos en los registros tras haber sido completada la operación. Esta arquitectura "no destructiva" permite a los compiladores organizar las instrucciones de modo que mantengan llenos los conductos (pipelines) del chip, y por tanto reutilizar los operandos optimizando la concurrencia.

3. Instrucciones simples, de formato fijo, con pocos modos de direccionamiento. Las instrucciones simples reducen de manera muy significativa el esfuerzo para su descodificación, y favorecen su ejecución en pipelines. Las instrucciones de longitud fija, con formatos fijos, implican que los campos de códigos de operación (opcodes) y de los operandos están siempre codificados en las mismas posiciones, permitiendo el acceso a los registros al mismo tiempo que se está descodificando el código de operación. Todas las instrucciones tienen una longitud equivalente a una palabra y están alineadas en la memoria en límites de palabra (word boundaries), ya que no pueden ser repartidas en pedazos que puedan estar en diferentes páginas.

4. Ausencia de microcódigo. El microcódigo no se presta a la ejecución en ciclos únicos, ya que requiere que el hardware sea dedicado a su interpretación dinámica. La programación en microcódigo no hace que el software sea más rápido que el programado con un conjunto de instrucciones simples. Todas las funciones y el control, en los procesadores RISC, están "cableados" (hardwired), para lograr una máxima velocidad y eficiencia.

5. Ejecución en conductos (pipelined). Las instrucciones simples, de formato fijo y ciclo único permiten que las diferentes etapas de los ciclos de ejecución (búsqueda o fetch, decodificación, ejecución, y escritura del resultado o result write-back) para instrucciones múltiples, se puedan realizar simultáneamente, de un modo más simple y eficaz.

6. Ejecución en ciclos únicos (single-cycle). El resultado directo de los conjuntos de instrucciones que ofrecen los procesadores RISC, es que cada instrucción puede ser ejecutada en un único ciclo de la CPU. Esto invalida la creencia de que las microinstrucciones en microcódigo, creadas para ser ejecutadas en un solo ciclo de procesador, son más rápidas que las instrucciones del lenguaje ensamblador. Ya que el caché está construido partiendo de la misma tecnología que el almacenamiento de control del microprograma, una única instrucción puede ser ejecutada a la misma velocidad que una microinstrucción. La ejecución en ciclos únicos también simplifica la gestión de las interrupciones y los conductos (pipelines).

RISC Moderno

Los diseños RISC han llevado a un gran número de plataformas y arquitecturas al éxito, algunas de las más grandes:

La línea MIPS Technologies Inc., que se encontraba en la mayoría de las computadoras de Silicon Graphics hasta 2006, y estuvo en las consolas ya descatalogadas Nintendo 64, PlayStation y PlayStation 2. Actualmente se utiliza en la PlayStation Portable y algunos routers.

La serie IBM POWER, utilizado principalmente por IBM en Servidores y superordenadores.

La versión PowerPC de Motorola e IBM (una versión de la serie IBM POWER) utilizada en los ordenadores AmigaOne, Apple Macintosh como el iMac, eMac, Power Mac y posteriores (hasta 2006). Actualmente se utiliza en muchos sistemas empotrados en

automóviles, routers, etc, así como en muchas consolas de videojuegos, como la Playstation 3, Xbox 360 y Nintendo Wii.

El procesador SPARC y UltraSPARC de Sun Microsystems y Fujitsu, que se encuentra en sus últimos modelos de servidores (y hasta 2008 también en estaciones de trabajo).

El PA-RISC y el HP/PA de Hewlett-Packard, ya descatalogados. El DEC Alpha en servidores HP AlphaServer y estaciones de trabajo AlphaStation, ya

descatalogados. El ARM – Se encuentra en dispositivos PALM, Nintendo DS, Game Boy Advance y en

múltiples PDAs, teléfonos móviles y reproductores multimedia (como el iPod).

RISC vs CISC

La siguiente tabla esquematiza algunas de las principales características de las arquitecturas RISC Y CISC.

RISC CISCÉnfasis en el software Énfasis en el hardwareIncluye el multi-reloj, instrucciones reducida

Solo-reloj, instrucciones complejas

Inter – registro: “CARGA” y “ALMACÉN” incorporado en instrucciones

Memoria a memoria: “CARGA” y “ALMACÉN” son las instrucciones independientes

Altos ciclos por segundo, tamaños de código pequeños

Ciclos bajos por segundo, tamaños de código grandes

Transistores usados para almacenar instrucciones complejas

Pasa más transistores en los registros de la memoria

Conjunto de instrucciones

Instrucciones de carga/almacenamiento

OPERANDO DESCRIPCIÓNLDSB Cargar byte con signoLDSH Cargar media palabra con signoLDUB Cargar byte sin signoLDUH Cargar media palabra sin signoLD Cargar palabraLDD Cargar doble palabraSTB Almacenar byteSTH Almacenar media palabraSTD Almacenar palabraSTDD Almacenar doble palabra

Instrucciones de desplazamiento

OPERANDO

DESCRIPCIÓN

SLL Desplazamiento lógico a la izquierdaSRL Desplazamiento lógico a la derecha

SRA Desplazamiento aritmético a la derecha

Instrucciones Booleanas

OPERANDO DESCRIPCIÓNAND YANDCC Y, ajustar iccANDN No YANDNCC No Y, ajustar iccOR OORCC O, ajustar iccORN No OORNCC No O, ajustar iccXOR O ExclusivaXORCC O Exclusiva, ajustar iccXNOR No O ExclusivaXNORCC No O Exclusiva, ajustar icc

Instrucciones aritméticas

OPERANDO DESCRIPCIÓNADD SumarADDCC Sumar, ajustar iccADDX Sumar con acarreoADDXCC Sumar con acarreo, ajustar iccSUB RestarSUBCC Restar, ajustar iccSUBX Restar con adeudoSUBXCC Restar con adeudo, ajustar iccMULSCC Paso de multiplicación, ajustar icc

Instrucciones de salto/bifurcación

OPERANDO DESCRIPCIÓNBCC Bifurcar si condiciónFBCC Bifurcar si condición de coma flotanteCBCC Bifurcar si condición del procesadorCALL Llamar a procedimientoJMPL Saltar y enlazarTCC Interceptar si condiciónSAVE Avanzar ventana de registrosRESTORE Mover ventanas hacia atrásRETT Retornar de interceptación

Instrucciones diversas

OPERANDO

DESCRIPCIÓN

SETHI Fijar los 22 bits altosUNIMP Instrucción no implementada (Interceptación)

RD Leer un registro especialWR Escribir en un registro especialIFLUSH Vaciar la caché de instrucciones

CUADRO COMPARATIVO

CISC RISCUna instrucción por circunstancia. Pequeñas instrucciones.

Instrucciones complejas. Instrucciones simples.

Lenta ejecución de la instrucción. Ejecución rápida de las instrucciones.

Pocas instrucciones por trabajo Varias instrucciones por trabajo específico.

MODOS DE DIRECCIONAMIENTO

El único modo de direccionamiento disponible, aparte del modo registro, es el modo de desplazamiento.

La dirección efectiva de un operando consiste en una dirección contenida en un registro más un desplazamiento.

EA=(R1 )+S (Constante)

EA=(R1 )+(R2)

FORMATO DE INSTRUCCIONES

El RISC emplea un formato de instrucciones de 32 bits.

Todas las instrucciones comienzan con un código de operación de 2 bits. En ciertas instrucciones, este código se amplía con bits de código de operación adicionales en otras partes del formato.

Optimización

El objetivo del compilador es mantener en registros los operandos necesarios para tantos cálculos como sea posible y minimizarlas operaciones de carga – almacenamiento. Se usa la siguiente aproximación, cada cantidad candidata a residir en un registro se asigna a un registro simbólico. Después el número ilimitado de registros simbólicos es asignado a un número fijo de registros reales. Los registros simbólicos cuyo uso no se solapa pueden compartir el mismo registro real. Si hay más cantidades que registros, algunas de las cantidades se asignan a posiciones de memoria y otras a registros. La técnica usada en los compiladores para RISC es el coloreado de grafos.

El problema es, dado un grafo asignar colores a los nodos de manera que nodos adyacentes tengan colores diferentes y se minimice el número de colores distintos. Se adapta una vez que el programa se ha analizado para construir un grafo de interferencias entre registros. Los nodos son los registros simbólicos. Si dos registros están “vivos” se unen por un arco para representar su interferencia. Se intenta colorear el grafo con “n” colores, donde “n” es el número de registro. Los nodos que no se pueden colorear se colocan en memoria.

Técnica del coloreado de grafos

Arquitectura

Una de las primeras decisiones a la hora de diseñar un microprocesador es decidir cuál será su juego de instrucciones. La decisión es trascendente por dos razones; primero, el juego de instrucciones decide el diseño físico del conjunto; segundo, cualquier operación que deba ejecutarse en el microprocesador deberá poder ser descrita en términos de un lenguaje de estas instrucciones. (Muro García, 2007)

La arquitectura RISC plantea en su filosofía de diseño una relación muy estrecha entre los compiladores y la misma arquitectura.

La meta principal es incrementar el rendimiento del procesador, ya sea optimizando alguno existente o se desee crear uno nuevo. Para esto se deben considerar tres áreas principales a cubrir en el diseño del procesador y estas son:

La arquitectura. La tecnología de proceso. El encapsulado.

La tecnología de proceso, se refiere a los materiales y técnicas utilizadas en la fabricación del circuito integrado, el encapsulado se refiere a cómo se integra un procesador con lo que lo rodea en un sistema funcional, que de alguna manera determina la velocidad total del sistema.

Aunque la tecnología de proceso y de encapsulado son vitales en la elaboración de procesadores más rápidos, es la arquitectura del procesador lo que hace la diferencia entre el rendimiento de una CPU (Control Process Unit) y otra. Y es en la evaluación de las arquítecturas RISC y CISC donde centraremos nuestra atención.

Dependiendo de cómo el procesador almacena los operandos de las instrucciones de la CPU, existen tres tipos de juegos de instrucciones:

1. Juego de instrucciones para arquitecturas basadas en pilas.2. Juego de instrucciones para arquitecturas basadas en acumulador.3. Juego de instrucciones para arquitecturas basadas en registros.

Las arquítecturas RISC y CISC son ejemplos de CPU con un conjunto de instrucciones para arquítecturas basadas en registros. (División de Ciencias Básicas e Ingeniería de la UAM)

Arquitecturas CISC

Los microprocesadores CISC tienen un conjunto de instrucciones que se caracteriza por ser muy amplio y permitir operaciones complejas entre operandos situados en la memoria o en los registros internos.

Figura 1. Microprocesadores CISC.

Este tipo de arquitectura dificulta el paralelismo entre instrucciones, por lo que en la actualidad la mayoría de los sistemas CISC de alto rendimiento implementan un sistema que convierte dichas instrucciones complejas en varias instrucciones simples, llamadas generalmente microinstrucciones.

La microprogramación es una característica importante y esencial de casi todas las arquítecturas CISC, por ejemplo Intel 8086, 8088, 80286, 80386, 80486; Motorola 68000, 68010, 68020, 68030, 6840.

La microprogramación significa que cada instrucción de máquina es interpretada por un microprograma localizado en una memoria en el circuito integrado del procesador.

En la década de los sesentas la microprogramación, por sus características, era la técnica más apropiada para las tecnologías de memorias existentes en esa época y permitía desarrollar también procesadores con compatibilidad ascendente. En consecuencia, los procesadores se dotaron de poderosos conjuntos de instrucciones.

Las instrucciones compuestas son decodificadas internamente y ejecutadas con una serie de microinstrucciones almacenadas en una ROM interna. Para esto se requieren de varios ciclos de reloj (al menos uno por microinstrucción).

Cuando el sistema operativo o una aplicación requieren de una de estas acciones, envía al procesador el nombre del comando para realizarla junto con el resto de información complementaria que se necesite. Pero cada uno de estos comandos de la ROM del CISC varían de tamaño y, por lo tanto, el chip debe en primer lugar verificar cuanto espacio requiere el comando para ejecutarse y poder así reservárselo en la memoria interna. Además, el procesador debe determinar la forma correcta de cargar y almacenar el comando, procesos ambos que ralentizan el rendimiento del sistema.

El procesador envía entonces el comando solicitado a una unidad que lo descodifica en instrucciones más pequeñas que podrán ser ejecutadas por un nanoprocesador, una especie de procesador dentro del procesador. Y al no ser las instrucciones independientes, pues son instrucciones menores procedentes de la descodificación de una instrucción mayor, sólo puede realizarse una instrucción cada vez.

A través de la compleja circuitería del chip, el nanoprocesador ejecuta cada una de las instrucciones del comando. El desplazamiento por esta circuitería también ralentiza el proceso. Para realizar una sola instrucción un chip CISC requiere de cuatro a diez ciclos de reloj. (MuroGarcía, 2007)

Entre las bondades de CISC destacan las siguientes:

Reduce la complejidad de crear compiladores. Permite reducir el costo total del sistema. Reduce los costos de desarrollo de software. Mejora la compactación de código. Facilita la depuración de errores.

Arquitecturas RISC

Buscando aumentar la velocidad del procesamiento se descubrió en base a experimentos que, con una determinada arquitectura de base, la ejecución de programas compilados directamente con microinstrucciones y residentes en memoria externa al circuito integrado resultaban ser más eficientes, gracias a que el tiempo de acceso de las memorias se fue decrementando conforme se mejoraba su tecnología de encapsulado.

Debido a que se tiene un conjunto de instrucciones simplificado, éstas se pueden implantar por hardware directamente en la CPU, lo cual elimina el microcódigo y la necesidad de decodificar instrucciones complejas.

En investigaciones hechas a mediados de la década de los setentas, con respecto a la frecuencia de utilización de una instrucción en un CISC y al tiempo para su ejecución, se observó lo siguiente:

Alrededor del 20% de las instrucciones ocupa el 80% del tiempo total de ejecución de un programa.

Existen secuencias de instrucciones simples que obtienen el mismo resultado que secuencias complejas predeterminadas, pero requieren tiempos de ejecución más cortos.

Las características esenciales de una arquitectura RISC pueden resumirse como sigue:

Estos microprocesadores siguen tomando como base el esquema moderno de Von Neumann.

Las instrucciones, aunque con otras características, siguen divididas en tres grupos:o Transferencia.o Operaciones.o Control de flujo.

Reducción del conjunto de instrucciones a instrucciones básicas simples, con la que pueden implantarse todas las operaciones complejas.

Arquitectura del tipo load-store (carga y almacena). Las únicas instrucciones que tienen acceso a la memoria son 'load' y 'store'; registro a registro, con un menor número de acceso a memoria.

Casi todas las instrucciones pueden ejecutarse dentro de un ciclo de reloj. Con un control implantado por hardware (con un diseño del tipo load-store), casi todas las instrucciones se pueden ejecutar cada ciclo de reloj, base importante para la reorganización de la ejecución de instrucciones por medio de un compilador.

Pipeline (ejecución simultánea de varias instrucciones). Posibilidad de reducir el número de ciclos de máquina necesarios para la ejecución de la instrucción, ya que esta técnica permite que una instrucción puede empezar a ejecutarse antes de que haya terminado la anterior.

El hecho de que la estructura simple de un procesador RISC conduzca a una notable reducción de la superficie del circuito integrado, se aprovecha con frecuencia para ubicar en el mismo, funciones adicionales: (División de Ciencias Básicas e Ingeniería de la UAM)

Unidad para el procesamiento aritmético de punto flotante. Unidad de administración de memoria. Funciones de control de memoria cache. Implantación de un conjunto de registros múltiples.

La idea estuvo inspirada también por el hecho de que muchas de las características que eran incluidas en los diseños tradicionales de CPU para aumentar la velocidad estaban siendo ignoradas por los programas que eran ejecutados en ellas. Además, la velocidad del procesador en relación con la memoria de la computadora que accedía era cada vez más alta.

Figura 2. Microprocesadores RISC.

Debido a que se tiene un conjunto de instrucciones simplificado, éstas se pueden implantar por hardware directamente en la CPU, lo cual elimina el microcódigo y la necesidad de decodificar instrucciones complejas.

La arquitectura RISC funciona de modo muy diferente a la CISC, su objetivo no es ahorrar esfuerzos externos por parte del software con sus accesos a la RAM, sino facilitar que las instrucciones sean ejecutadas lo más rápidamente posible. La forma de conseguirlo es simplificando el tipo de instrucciones que ejecuta el procesador. Así, las instrucciones más breves y sencillas de un procesador RISC son capaces de ejecutarse mucho más aprisa que las instrucciones más largas y complejas de un chip CISC. Sin embargo, este diseño requiere de mucha más RAM y de una tecnología de compilador más avanzada. (Muro García, 2007)

La relativa sencillez de la arquitectura de los procesadores RISC conduce a ciclos de diseño más cortos cuando se desarrollan nuevas versiones, lo que posibilita siempre la aplicación de las más recientes tecnologías de semiconductores. Por ello, los procesadores RISC no solo tienden a ofrecer una capacidad de procesamiento del sistema de 2 a 4 veces mayor, sino que los saltos de capacidad que se producen de generación en generación son mucho mayores que en los CISC.

Por otra parte, es necesario considerar también que:

La disponibilidad de memorias grandes, baratas y con tiempos de acceso menores de 60 ns. en tecnologías CMOS.

Módulos SRAM (Memoria de acceso aleatorio estática) para memorias cache con tiempos de acceso menores a los 15 ns.

Tecnologías de encapsulado que permiten realizar más de 120 terminales.

Esto ha hecho cambiar, en la segunda mitad de la década de los ochentas, esencialmente las condiciones técnicas para arquitecturas RISC. (División de Ciencias Básicas e Ingeniería de la UAM)

Los comandos que incorpora el chip RISC en su ROM constan de varias instrucciones pequeñas que realizan una sola tarea. Las aplicaciones son aquí las encargadas de indicar al procesador qué combinación de estas instrucciones debe ejecutar para completar una operación mayor.

Además, los comandos de RISC son todos del mismo tamaño y se cargan y almacenan del mismo modo. Al ser estas instrucciones pequeñas y sencillas, no necesitan ser descodificadas en instrucciones menores como en el caso de los chips CISC, pues ya constituyen en sí unidades descodificadas. Por ello, el procesador RISC no gasta tiempo verificando el tamaño del comando, en descodificarlo ni en averiguar cómo cargarlo y guardarlo.

El procesador RISC puede además ejecutar hasta 10 comandos a la vez pues el compilador del software es el que determina qué comandos son independientes y por ello es posible ejecutar varios a la vez. Y al ser los comandos del RISC más sencillos, la circuitería por la que pasan también es más sencilla. Estos comandos pasan por menos transistores, de forma que se ejecutan con más rapidez. Para ejecutar una sola instrucción normalmente les basta con un ciclo de reloj. (MuroGarcía, 2007)

Entre las ventajas de RISC tenemos las siguientes:

La CPU trabaja más rápido al utilizar menos ciclos de reloj para ejecutar instrucciones. Utiliza un sistema de direcciones no destructivas en RAM. Eso significa que a

diferencia de CISC, RISC conserva después de realizar sus operaciones en memoria los dos operandos y su resultado, reduciendo la ejecución de nuevas operaciones.

Cada instrucción puede ser ejecutada en un solo ciclo del CPU.

Papel de los Compiladores en un Sistema RISC

El compilador juega un papel clave para un sistema RISC equilibrado.

Todas las operaciones complejas se trasladan al microprocesador por medio de conexiones fijas en el circuito integrado para agilizar las instrucciones básicas más importantes. De esta manera, el compilador asume la función de un mediador inteligente entre el programa de aplicación y el microprocesador. Es decir, se hace un gran esfuerzo para mantener al hardware tan simple como sea posible, aún a costa de hacer al compilador considerablemente más complicado. Esta estrategia se encuentra en clara contra posición con las máquinas CISC que tienen modos de direccionamiento muy complicados. En la práctica, la existencia en algunos modos de direccionamiento complicados en los microprocesadores CISC, hacen que tanto el compilador como el microprograma sean muy complicados.

No obstante, las máquinas CISC no tienen características complicadas como carga, almacenamiento y salto que consumen mucho tiempo, las cuales en efecto aumentan la complejidad del compilador.

Para suministrar datos al microprocesador de tal forma que siempre esté trabajando en forma eficiente, se aplican diferentes técnicas de optimización en distintos niveles jerárquicos del software.

Los diseñadores de RISC en la empresa MIP y en Hewlett Packard trabajan según la regla siguiente:

Una instrucción ingresa en forma fija en el circuito integrado del procesador (es decir, se alambra físicamente en el procesador) si se ha demostrado que la capacidad total del sistema se incrementa en por lo menos un 1%.

En cambio, los procesadores CISC, han sido desarrollados por equipos especializados de las empresas productoras de semiconductores y con frecuencia el desarrollo de compiladores se sigue por separado. Por consiguiente, los diseñadores de los compiladores se encuentran con una interfaz hacia el procesador ya definido y no pueden influir sobre la distribución óptima de las funciones entre el procesador y compilador.

Las empresas de software que desarrollan compiladores y programas de aplicación, tienden por razones de rentabilidad, a utilizar diferentes procesadores como usuarios de su software en lugar de realizar una optimización completa, y aprovechar así las respectivas características de cada uno. Lo cual también genera otros factores negativos de eficiencia. Esta limitación de las posibilidades de optimización del sistema, que viene dada a menudo por una obligada compatibilidad, se superó con los modernos desarrollos RISC. (División de Ciencias Básicas eIngeniería de la UAM)

Segmentación

La segmentación es un método por el cual se consigue aumentar el rendimiento de algunos sistemas electrónicos digitales. Es aplicado, sobre todo, en microprocesadores. El nombre viene de que para impulsar el gas en un oleoducto a la máxima velocidad es necesario dividir el oleoducto en tramos y colocar una bomba que dé un nuevo impulse al gas. El símil con la programación existe en que los cálculos deben ser registrados o sincronizados con el reloj cada cierto tiempo para que la ruta crítica (tramo con más carga o retardo computacional entre dos registros de reloj) se reduzca.

La ruta crítica es en realidad la frecuencia máxima de trabajo alcanzada por el conjunto. A mayor ruta crítica (tiempo o retraso entre registros) menor es la frecuencia máxima de trabajo y a menor ruta crítica mayor frecuencia de trabajo. La una es la inversa de la otra. Repartir o segmentar equitativamente el cálculo hace que esa frecuencia sea la óptima a costa de más área para el almacenamiento o registro de los datos intervinientes y de un retraso o latencia (en ciclos de reloj/tiempo) en la salida del resultado equivalente al número de segmentaciones o registros realizados. La ventaja primordial de este sistema es que, tal y como se muestra en la imagen, una vez el pipe está lleno, es decir, después de una latencia de cuatro en la imagen, los resultados de cada comando vienen uno tras otro cada flanco de reloj y sin latencia extra por estar encadenados dentro del mismo pipe. Todo esto habiendo maximizado la frecuencia máxima de trabajo.

Figura 3. Programa de instrucciones en el Intel Pentium IV.

El alto rendimiento y la velocidad elevada de los modernos procesadores, se debe, principalmente a la conjunción de tres técnicas:

Arquitectura Harvard (arquitectura que propicia el paralelismo) Procesadores RISC La propia segmentación

Figura 4. Detalle de la segmentación de instrucciones.La segmentación consiste en descomponer la ejecución de cada instrucción en varias etapas

para poder empezar a procesar una instrucción diferente en cada una de ellas y trabajar con varias a la vez.

Figura 5. Arquitectura Harvard.

En el caso del procesador DLX podemos encontrar las siguientes etapas en una instrucción:

IF: búsquedaID: decodificación

EX: ejecución de unidad aritmética lógicaMEM: memoriaWB: escritura

Cada una de estas etapas de la instrucción usa en exclusiva un hardware determinado del procesador, de tal forma que la ejecución de cada una de las etapas en principio no interfiere en la ejecución del resto.

En el caso de que el procesador no pudiese ejecutar las instrucciones en etapas segmentadas, la ejecución de la siguiente instrucción sólo se podría llevar a cabo tras la finalización de la primera. En cambio en un procesador segmentado, salvo excepciones de dependencias de datos o uso de unidades funcionales, la siguiente instrucción podría iniciar su ejecución tras acabar la primera etapa de la instrucción actual.

Otro ejemplo de lo anterior, en el caso del PIC, consiste en que el procesador realice al mismo tiempo la ejecución de una instrucción y la búsqueda del código de la siguiente. (Wikipedia,Segmentación (informática), 2009)

Segmentación de Cauce

La segmentación de cauce, también denominada pipeline, es una técnica empleada en el diseño de procesadores, basada en la división de la ejecución de las instrucciones en etapas, consiguiendo así que una instrucción empiece a ejecutarse antes de que hayan terminado las anteriores y, por tanto, que haya varias instrucciones procesándose simultáneamente.

Cada una de las etapas debe completar sus acciones en un ciclo de reloj, pasando sus resultados a la etapa siguiente y recibiéndolos de la anterior. Para eso es necesario almacenar los datos en registros intermedios. Cualquier valor que pueda ser necesario en una etapa posterior debe irse propagando a través de esos registros intermedios hasta que ya no sea necesario.

Para conseguir la segmentación es necesario que una instrucción utilice solamente una etapa en cada ciclo de ejecución.

Figura 6. Cómo se conforma la segmentación de instrucción.

Ya que todas las etapas deben de tardar lo mismo en su ejecución, el tiempo de ciclo será el de la etapa más lenta, más el del retardo provocado por la utilización de los registros intermedios. Comparando este esquema con el multiciclo, el tiempo de ciclo será más lento, pero el CPI (Ciclos Por Instrucción) será menor, lo que provoca un aumento del rendimiento. Ya que si no tenemos en cuenta los riesgos estructurales (que pueden provocar paradas en el pipeline), tendríamos que en cada ciclo de reloj, termina de ejecutarse una instrucción (CPI = 1).

Ejemplo

Un ejemplo sencillo que utiliza esta técnica es el procesador DLX, con 5 etapas (IF, ID, EX, MEM y WB). Una instrucción utiliza en un ciclo solamente una de esas etapas. Cuando termina ese ciclo, pasa a la siguiente etapa, dejando libre la anterior, por lo que esta podría ser utilizada en ese momento por la siguiente instrucción.

Viendo el cauce de ejecución se quedaría, idealmente, así:

N° CICLO

1 2 3 4 5 6 7 8 9 10

Instr. 1 IF ID EX MEM WB

Instr. 2 IF ID EX MEM WB

Instr. 3 IF ID EX MEM WB

Instr. 4 IF ID EX MEM WB

Instr. 5 IF ID EX MEM

WB

Instr. 6 IF ID EX MEM WB

De esta manera se aprecia que, una vez está el pipeline lleno, se termina de ejecutar una instrucción en cada ciclo: En el ciclo nº 5 finaliza la primera instrucción, en el nº 6 la segunda, etc.

Riesgos de Datos y de Control

El empleo de esta técnica conlleva diversos riesgos de datos, ya que al empezar a ejecutar instrucciones antes de terminar las anteriores puede provocar que se necesite leer/escribir un registro antes de que este haya sido escrito/leído por la instrucción anterior/siguiente. Esos riesgos de datos se pueden clasificar como:

RAW (read after write): una instrucción posterior trata de leer un operando antes de que lo escriba una anterior.

WAR (write after read): una instrucción posterior trata de escribir su resultado antes de que lo haya leído una anterior.

WAW (write after write): una escritura posterior se produce antes que otra escritura anterior en el mismo destino.

La técnica más sencilla para evitar estos riesgos sería, cuando se detecte un riesgo, parar la ejecución de la instrucción que vaya a causar el riesgo, (insertando instrucciones NOP, o burbujas), hasta que hayan terminado de ejecutarse todas las instrucciones anteriores. Esta técnica supone demasiadas paradas en la ejecución, lo que supone una caída considerable del rendimiento.

Otra técnica para solucionar los riesgos RAW es la del adelantamiento, consistente en copiar un valor de un registro intermedio posterior en uno anterior, para que la instrucción que venga detrás pueda utilizar los valores, sin tener que esperar a que termine del todo la instrucción anterior.

Para intentar solucionar los demás riesgos se emplean técnicas más avanzadas como la técnica Tomasulo o la de Scoreboard (ambas de predicción dinámica).

De una manera u otra, lo que se pretende con cualquiera de estas técnicas es reducir lo máximo posible los ciclos de parada, ya que incrementan el CPI, el cual idealmente es de 1. El compilador también influye notablemente en la búsqueda del CPI ideal, puesto que otra manera de evitar riesgos y, por lo tanto, posibles ciclos de parada, podría ser cambiar el orden de ejecución de las instrucciones, evitando siempre, por supuesto, que no cambie el resultado del programa.

Aparte de los riesgos de datos, también existen los riesgos de control, provocados por los saltos condicionales. Estos procesadores empiezan a mandar instrucciones a ejecutar antes de saber si esas instrucciones deben de ejecutarse (ya que hasta que no se procesa la condición de salto, no se sabe si será o no tomado), por lo que deben de tener maneras de deshacer cambios, o de poder descartarlos, si han empezado a ejecutar instrucciones que no corresponden, además del desperdicio de ciclos que supone el haber empezado a ejecutar instrucciones inútiles.

Por esto, se emplean técnicas para intentar predecir si un salto condicional será tomado o no, y en caso de equivocarse, que la penalización sea la mínima posible. (Wikipedia, Segmentación decauce, 2009)

Procesadores Superescalares

El procesamiento superescalar es la última de una serie de innovaciones tendientes a producir procesadores cada vez más rápidos. Explotando el paralelismo a nivel de instrucción, los superescalares son capaces de ejecutar más de una instrucción por ciclo de reloj (dos, tres, cuatro, ocho ya es mucho!).

Los procesadores superescalares pueden iniciar la ejecución simultánea de varias instrucciones escalares en paralelo de manera que se pueden operar varios elementos de un vector dentro de una misma iteración.

Para ésto, es necesario que existan varias unidades aritmético-lógicas, de punto flotante y de control. El proceso que sigue el micro es transparente al programa, aunque el compilador puede ayudar analizando el código y generando un flujo de instrucciones optimizado. Veamos cómo se ejecutarían las instrucciones en un procesador superescalar de que tiene duplicadas las subunidades que lo componen:

Figura 7. Ejecución de instrucciones en un procesador superescalar.

Aunque esto mejora la velocidad global del sistema, los conflictos de datos crecen. Si antes las instrucciones se encontraban muy próximas, ahora se ejecutan simultaneamente. Esto hace necesario un chequeo dinámico para detectar y resolver los posibles conflictos. (ProcesadoresSuperescalares)

Los procesadores escalares son procesadores segmentados que pueden procesar más de instrucción por ciclo en todas las etapas, incorporando el hardware necesario para la gestión dinámica de los riesgos de datos y de control. La organización de un procesador superescalar se muestra en la siguiente figura (Desconocido):

Figura 8. Organización de los procesadores superescalares.

Superescalar es el término utilizado para designar un tipo de microarquitectura de procesador capaz de ejecutar más de una instrucción por ciclo de reloj. El término se emplea por oposición a la microarquitectura escalar que sólo es capaz de ejecutar una instrucción por ciclo de reloj. En la clasificación de Flynn, un procesador superescalar es un procesador de tipo MIMD (multiple instruction multiple data).

La microarquitectura superescalar utiliza el paralelismo de instrucciones además del paralelismo de flujo, éste último gracias a la estructura en pipeline. La estructura típica de un procesador superescalar consta de un pipeline con las siguientes etapas (Wikipedia, Superescalar,2009):

Lectura (fetch) Decodificación (decode) Lanzamiento (dispatch)

Ejecución (execute) Escritura (writeback) Finalización (retirement)

La forma más usual de organizar la microarquitectura de un procesador superescalar se muestra en la siguiente figura (Desconocido):

Figura 9. Organización de la microarquitectura de un procesador superescalar.

En un procesador superescalar, el procesador maneja más de una instrucción en cada etapa. El número máximo de instrucciones en una etapa concreta del pipeline se denomina grado, así un procesador superescalar de grado 4 en lectura (fetch) es capaz de leer como máximo cuatro instrucciones por ciclo. El grado de la etapa de ejecución depende del número y del tipo de las unidades funcionales.

Un procesador superescalar suele tener unidades funcionales independientes de los tipos siguientes:

Unidad Aritmético Lógica (ALU) Unidad de Lectura/Escritura en Memoria (Load/Store Unit) Unidad de Punto Flotante (Floating Point Unit) Unidad de Salto (Branch Unit)

Un procesador superescalar es capaz de ejecutar más de una instrucción simultáneamente únicamente si las instrucciones no presentan algún tipo de dependencia (hazard). Los tipos de dependencia entre instrucciones son:

Dependencia estructural, esta ocurre cuando dos instrucciones requieren el mismo tipo unidad funcional y su número no es suficiente.

Dependencia de datos, esta ocurre cuando una instrucción necesita del resultado de otra instrucción para ejecutarse, por ejemplo R1≤ R2+R3 y R4 ≤R1+5

Dependencia de escritura o falsa dependencia , esta ocurre cuando dos instrucciones necesitan escribir en la misma memoria, por ejemplo R1≤ R2+R3 y R1≤ R1+5

La detección y resolución de las dependencias entre instrucciones puede ser estática (durante la compilación) o dinámica, es decir, a medida que se ejecuta un programa, generalmente durante la etapas de codificación y lanzamiento de las instrucciones.

La detección y resolución dinámica de las dependencias entre instrucciones suele realizarse mediante alguna variante del algoritmo de Tomasulo que permite la ejecución de instrucciones en un orden distinto al del programa también llamada ejecución en desorden. La eficacia de un procesador superescalar viene limitada por un lado por la dificultad en suministrar al procesador suficientes instrucciones que puedan ser ejecutadas en paralelo y por otro lado por las prestaciones de la jerarquía de memorias.

Si las instrucciones de salto son un problema para los procesadores con pipeline en general, en el caso de los procesadores superescalares, el problema se multiplica ya que un parón en el pipeline tiene consecuencias en un número mayor de instrucciones. Por esta razón, los fabricantes de procesadores recurren a técnicas de ejecución especulativa y diseñan algoritmos de predicción de saltos cada vez más sofisticados así como sistemas de almacenamiento de instrucciones por trazas (trace caches).

Las arquitecturas superescalares adolecen de una estructura compleja y de un mal aprovechamiento de sus recursos debido en parte a la dificultad en encontrar suficientes instrucciones paralelizables. Una forma de obtener un mayor número de instrucciones paralelizables es aumentar la ventana de instrucciones, es decir el conjunto de instrucciones que la unidad de lanzamiento considera como candidatas a ser lanzadas en un momento dado.

Desafortunadamente la complejidad del procesador superescalar aumenta desproporcionadamente con respecto al tamaño de dicha ventana lo que se traduce por un ralentizamiento general del circuito. Otra forma de obtener más instrucciones paralelizables es manipulando instrucciones de más de un programa a la vez, lo que se conoce bajo el nombre de multitarea simultánea o multithreading simultáneo.

Mientras las primeras CPUs superescalares disponían de dos ALUs y una sola FPU, un procesador moderno como el PowerPC 970 incluye cuatro ALUs y dos FPUs, además de dos unidades SIMD. Si el despachador no es eficiente haciendo trabajar lo máximo posible a estas unidades, el rendimiento global del procesador se verá mermado. (Wikipedia, Superescalar, 2009)

Algunas de las diferencias entre procesadores superescalares y segmentados son:

La etapa de captación de instrucciones (IF) es capaz de leer varias instrucciones por ciclo desde el nivel de caché más elevado (L1). Las instrucciones pasan, en el orden que se han captado, a una cola desde donde se introducen ordenadamente en la etapa de decodificación, tantas como dicha etapa sea capaz de decodificar por ciclo. Al final de la etapa de decodificación se almacena en una serie de estructuras (ventana de instrucciones, estaciones de reserva, buffer de renombramiento, buffer de reordenamiento, etc.).

Un procesador superescalar debe de ser capaz de identificar el paralelismo entre instrucciones (ILP) que existe en el código y permitir que los recursos se usen lo más eficazmente en la ejecución paralela de las instrucciones.

La siguiente figura muestra cómo las instrucciones pueden emitirse ordenadamente o desordenadamente:

La siguiente figura muestra algunas de las diferencias entre la ejecución de una secuencia de instrucciones en procesador segmentado y su ejecución en un procesador superescalar con distintas opciones de ordenación entre la emisión (ISS) y la finalización de instrucciones (WB).

Algunos de los problemas que se plantean en las distintas etapas de un procesador superescalar son (Desconocido):

1. La decodificación paralela y el uso de predecodificación2. La emisión paralela de instrucciones a las unidades funcionales3. La ejecución paralela de las operaciones codificadas en las instrucciones en las distintas

unidades funcionales.4. La finalización del procesamiento de instrucciones.5. El mantenimiento de la consistencia secuencial mediante el desacoplo de la ejecución de

la instrucción y la escritura de resultados.

Procesamiento de las Instrucciones de Salto

El salto retardado no resulta útil ya que la unidad de emisión decide dinámicamente qué instrucciones pasan a ejecutarse, independientemente del orden que tengan en el código. La detección anticipada de la instrucción de salto (early branch detection) se clasifica en:

Detección paralela Detección anticipada Detección integrada en la captación

Si la instrucción de salto no se ha terminado de evaluar en el momento en que la instrucción de salto evalúa la condición de salto. Se suele usar el procesamiento especulativo. Algunas alternativas para la gestión de los saltos condicionales son (Desconocido):

Bloqueo del procesamiento del salto: se bloquea la instrucción de salto hasta que la condición esté disponible.

Procesamiento especulativo de los saltos: la ejecución prosigue por el camino más probable. Si se ha errado en la predicción hay que recuperar el camino correcto.

Múltiples caminos. Se ejecutan los dos caminos posibles después de un salto hasta que la condición de salto se evalúa. En ese momento se cancela el camino incorrecto.

Instrucciones de ejecución condicional. Ejemplo: procesadores ARM. Eliminar o reducir instrucciones de salto, introduciendo en el repertorio de instrucciones máquina una serie de instrucciones que implementan operaciones condicionales (instrucciones con predicado o instrucciones de ejecución condicional o vigilada).

OpenRISC

OpenRISC es el proyecto insignia original de la comunidad OpenCores. Este proyecto pretende desarrollar una serie de arquitecturas de CPU RISC de código abierto de propósito general. La primera (y de momento única) descripción arquitectónica está en la OpenRISC 1000, describiendo

una familia de procesadores de 32 y 64 bits con coma flotante opcional y soporte de procesamiento de vectores.

Un equipo de OpenCores ha provisto la primera implementación, la OpenRISC 1200, escrito en el lenguaje de descripción de hardware Verilog. El diseño del hardware fue liberado bajo la GNU Lesser General Public License, mientras que los modelos y el firmware se distribuyen bajo la GNU General Public License. Se desarrolló una implementación SoC de referencia basado en la OpenRISC 1200, conocida como ORPSoC (the OpenRISC Reference Platform System-on-Chip). Un número de grupos demostraron ORPSoC y otros diseños basados en OR1200. (Wikipedia,OpenRISC, 2010)

Aplicaciones

Las arquitecturas CISC utilizadas desde hace 15 años han permitido desarrollar un gran número de productos de software. Ello representa una considerable inversión y asegura a estas familias de procesadores un mercado creciente. Sin embargo, simultáneamente aumentan las aplicaciones en las cuales la capacidad de procesamiento que se pueda obtener del sistema es más importante que la compatibilidad con el hardware y el software anteriores, lo cual no solo es válido en los subsistemas de alta capacidad en el campo de los sistemas llamados "embedded", en los que siempre dominaron las soluciones especiales de alta capacidad de procesamiento sino también para las estaciones de trabajo ("workstations"). Esta clase de equipos se han introducido poco a poco en oficinas, en la medicina y en bancos, debido a los cada vez mas voluminosos y complejos paquetes de software que con sus crecientes requerimientos de reproducción visual, que antes se encontraban solo en el campo técnico de la investigación y desarrollo.

En este tipo de equipos, el software de aplicación, se ejecuta bajo el sistema operativo UNIX, el cual es escrito en lenguaje C, por lo que las arquítecturas RISC actuales están adaptadas y optimizadas para este lenguaje de alto nivel. Por ello, todos los productores de estaciones de trabajo de renombre, han pasado en pocos años, de los procesadores CISC a los RISC, lo cual se refleja en el fuerte incremento anual del número de procesadores RISC, (los procesadores RISC de 32 bits han visto crecer su mercado hasta en un 150% anual). En pocos años, el RISC conquistará de 25 al 30% del mercado de los 32 bits, pese al aparentemente abrumador volumen de software basado en procesadores con el estándar CISC que se ha comercializado en todo el mundo.

La arquitectura MIPS-RISC ha encontrado, en el sector de estaciones de trabajo, la mayor aceptación. Los procesadores MIPS son fabricados y comercializados por cinco empresas productoras de semiconductores, entre las que figuran NEC y Siemens. Los procesadores de los cinco proveedores son compatibles en cuanto a las terminales, las funciones y los bits. (División deCiencias Básicas e Ingeniería de la UAM)

Procesadores ARM

ARM (Advanced RISC Machines) es una familia de microprocesadores RISC diseñados por la empresa Acorn Computers y desarrollados por Advanced RISC Machines Ltd., una empresa derivada de la anterior.

El diseño del ARM se ha convertido en uno de los más usados del mundo, desde discos duros hasta juguetes. Hoy en día, cerca del 75% de los procesadores de 32 bits poseen este chip en su

núcleo.

Los núcleos de ARM se utilizan en diversas aplicaciones como el Game Boy Advance, Videoconsolas GPX2, calculadoras HP-49/50, Nintendo DS, Motorola Z6, iPhone, consola Pandora y versiones futuras de Symbian .

El juego de instrucciones del ARM es similar al del MOS 6502, pero incluye características adicionales que le permiten conseguir un mejor rendimiento en su ejecución. Para mantener el concepto tradicional de RISC, se incluyó el comando de ejecución en un tiempo bastante bueno, siendo por lo general, en un ciclo. La característica más interesante es el uso de los 4 bits como código condicional en la parte superior de cada instrucción, haciendo que cada instrucción pueda ser una condición.

Este corte permite aumentar el espacio para algunos desplazamientos en el acceso a la memoria, pero también permite evitar caer en ciclos fuera de control cuando la aplicación sea para pequeñas instrucciones condicionadas. El ejemplo estándar es el Máximo común divisor, según el algoritmo de Euclides.

Otra característica única del juego de instrucciones es la posibilidad de añadir shifts y rotar en el procesamiento de datos (aritmético, lógico y movimiento de registros), por ejemplo, la instrucción en C "a += (j << 2);" puede ser mejorada como una instrucción simple en el ARM, permitiendo la reubicación del registro.

Todo esto ocasiona que se necesiten menos operaciones de carga y almacenamiento, mejorando el rendimiento.

El procesador ARM también tiene algunas características que son raras en otras arquitecturas también consideradas RISC, como el direccionamiento relativo, y el pre y post incremento en el modo de direccionamiento.

Tiene dos modos de funcionamiento: el ARMI con instrucciones que ocupan 4 bytes, más rápidas y potentes (hay instrucciones que sólo están en este modo) pero con mayor consumo de memoria y de electricidad. Y el modo THUMB, más limitado, con instrucciones que ocupan 2 bytes y con menor consumo de corriente. (Wikipedia, ARM, 2010)

Figura 10. Procesador ARM en una impresora HP.

Sun SPARC

SPARC (del inglés Scalable Processor ARChitecture) es una arquitectura RISC big-endian. Es decir, una arquitectura con un conjunto reducido de instrucciones.

Fue originalmente diseñada por Sun Microsystems y dirigido por el ingeniero Kaa en 1985, se basa en los diseños RISC I y II de la Universidad de California en Berkeley que fueron definidos entre los años 1980 y 1982.

La empresa Sun Microsystems diseñó esta arquitectura y la licenció a otros fabricantes como Texas Instruments, Cypress Semiconductor, Fujitsu, LSI Logic entre otros.

SPARC es la primera arquitectura RISC abierta y como tal, las especificaciones de diseño están publicadas, así otros fabricantes de microprocesadores pueden desarrollar su propio diseño.

Una de las ideas innovadoras de esta arquitectura es la ventana de registros que permite hacer fácilmente compiladores de alto rendimiento y una significativa reducción de memoria en las instrucciones load/store en relación con otras arquitecturas RISC. Las ventajas se aprecian sobre todo en programas grandes.

La CPU SPARC está compuesta de una unidad entera, UI (Integer Unit) que procesa la ejecución básica y una FPU (Floating-Point Unit) que ejecuta las operaciones y cálculos de reales. La IU y la FPU pueden o no estar integradas en el mismo chip.

Aunque no es una parte formal de la arquitectura, las computadoras basadas en sistemas SPARC de Sun Microsystems tienen una unidad de manejo de memoria (MMU) y un gran caché de direcciones virtuales (para instrucciones y datos) que están dispuestos periféricamente sobre un bus de datos y direcciones de 32 bits. (Wikipedia, Sun SPARC, 2009)

Figura 11. Sun UltraSparc II.

Principales Características

Su característica distintiva es utilizar ventanas de registros. 32 registros de "enteros" de 32 bits. 16 registros de punto flotante de 64 bits (para el caso de doble precisión) que se

pueden utilizar como 32 registros de 32 bits (para precisión simple). Modos de direccionamiento:

o Inmediato, (constantes de 13 bits).o Directo, (offset de 13 bits).o Indirecto, (registro + offset de 13 bits o registro + registro).

Utiliza instrucciones retardadas (saltos, load y store ). Manejo de memoria:

o Espacio virtual de 4 Gigabytes.o Unidad de manejo de memoria (MMU) que trabaja con páginas de tamaño

configurable.

MIPS

MIPS (Microprocessor without Interlocked Pipeline Stages) es toda una familia de microprocesadores de arquitectura RISC desarrollados por MIPS Technologies. Cifras de 1999 estiman que uno de cada tres procesadores RISC fabricados en el mundo está basado en el MIPS.

Los diseños del MIPS son utilizados en la línea de productos informáticos de SGI; en muchos sistemas integrados; en dispositivos para Windows CE; routers Cisco; y videoconsolas como la Nintendo 64 o las Sony PlayStation, PlayStation 2 y PlayStation Portable.

Las primeras arquitecturas MIPS fueron implementadas en 32 bits (generalmente rutas de datos y registros de 32 bits de ancho), si bien versiones posteriores fueron implementadas en 64 bits. Existen cinco revisiones compatibles hacia atrás del conjunto de instrucciones del MIPS, llamadas MIPS I, MIPS II, MIPS III, MIPS IV y MIPS 32/64. En la última de ellas, la MIPS 32/64

Release 2, se define a mayores un conjunto de control de registros. Asimismo están disponibles varias "extensiones", tales como la MIPS-3D consistente en un simple conjunto de instrucciones SIMD en coma flotante dedicadas a tareas 3D comunes, la MDMX(MaDMaX) compuesta por un conjunto más extenso de instrucciones SIMD enteras que utilizan los registros de coma flotante de 64 bits, la MIPS16 que añade compresión al flujo de instrucciones para hacer que los programas ocupen menos espacio (presuntamente como respuesta a la tecnología de compresión Thumb de la arquitectura ARM) o la reciente MIPS MT que añade funcionalidades multithreading similares a la tecnología HyperThreading de los procesadores Intel Pentium 4.

Figura 12. Un microprocesador MIPS R4400 fabricado por Toshiba.

Debido a que los diseñadores crearon un conjunto de instrucciones tan claro, los cursos sobre arquitectura de computadores en universidades y escuelas técnicas a menudo se basan en la arquitectura MIPS. El diseño de la familia de CPU's MIPS influiría de manera importante en otras arquitecturas RISC posteriores como los DEC Alpha.

Entre los fabricantes de estaciones de trabajo basadas en procesadores MIPS destacan SGI, MIPS Computer Systems, Inc., Olivetti, Siemens-Nixdorf, Acer, Digital Equipment Corporation, NEC y DeskStation. Varios sistemas operativos fueron portados a la arquitectura, ejemplos de ello son el SGI IRIX, Microsoft Windows NT (aunque el soporte para MIPS finalizó con el lanzamiento de Windows NT 4.0) y Windows CE, Linux, BSD, UNIX System V, SINIX, MIPS Computer Systems RISC/os, entre otros.

Sin embargo, el uso del MIPS como procesador principal de estaciones de trabajo ha caído, y SGI ha anunciado sus planes de cesar el desarrollo de iteraciones de alto rendimiento de la arquitectura MIPS en favor de procesadores basados en la tecnología Intel IA64 (véase la sección "Otros modelos y planes futuros").

Por otra parte, el uso de microprocesadores MIPS en sistemas integrados es probable que se mantenga gracias al bajo consumo de energía y características térmicas de las implementaciones integradas, así como a la gran disponibilidad de herramientas de desarrollo y de expertos conocedores de la arquitectura.

Otro miembro de la familia MIPS es el R6000, una implementación ECL de la arquitectura MIPS fabricada por Bipolar Integrated Technology. El R6000 introdujo el juego de instrucciones MIPS II. Su arquitectura TLB y de caché son diferentes del resto de miembros de la familia MIPS. El R6000 no proporcionó los resultados esperados, y aunque fue empleado en algunas máquinas Control Data, rápidamente desapareció del mercado de los mainstream. El PMC-Sierra RM7000 fue una versión del R5000 con una caché integrada de nivel 2 de 256 kB y un controlador para una caché opcional de tercer nivel. Diseñado en un principio para sistemas integrados como los procesadores gráficos SGI y varias soluciones de redes de Cisco. El nombre R9000 nunca fue utilizado.

SGI intentó una vez migrar de la plataforma MIPS a la Intel Itanium, habiendo terminado su desarrollo con el R10000. Los grandes retrasos en la presentación del Itanium hicieron que el número de procesadores basados en MIPS instalados continuó creciendo. En 1999 quedó claro que el proceso de desarrollo había sido cerrado demasiado pronto, y resultado de ello son las versiones R14000 y R16000. SGI tanteó la posibilidad de añadir una FPU más compleja al estilo de la del R8000 en las últimas iteraciones, así como la de lanzar un procesador de doble núcleo, pero los problemas financieros de la empresa y el uso oficial y soportado de la emulación QuickTransit para ejecutar binarios IRIX sobre Altix provocaron el cese definitivo del desarrollo de hardware IRIX/MIPS.

En los últimos años gran parte de la tecnología empleada en las distintas generaciones MIPS ha sido ofrecida como diseños de "IP-cores" (bloques de construcción) para procesadores integrados. Se ofertan los núcleos básicos de 32 y 64 bits, conocidos respectivamente como 4K y 5K respectivamente, y con licencias MIPS32 y MIPS64. Estos núcleos pueden ser combinados con unidades añadidas tales como FPUs, sistemas SIMD, dispositivos de E/S, etc.

Los núcleos MIPS han sido comercialmente exitosos, siendo empleados actualmente en muchas aplicaciones industriales y de consumo. Pueden encontrarse en los más modernos routers Cisco y Linksys , cablemódems y módems ADSL, tarjetas inteligentes, controladoras de impresoras láser, decodificadores de TV, robots, ordenadores de mano, Sony PlayStation 2 y Sony PlayStation Portable.

En móviles y PDA's, sin embargo, el núcleo MIPS fue incapaz de desbancar a su competidor de arquitectura ARM. (Wikipedia, MIPS (procesador), 2010)

Bibliografía

Desconocido. (s.f.). Procesadores Paralelos. Recuperado el 14 de Enero de 2010, de Quegrande.org: http://quegrande.org/apuntes/EI/2/ECm1/seminarios/08-09/seminario_-_procesadores_paralelos.pdf

Stallings, W. (s.f.). Organización y arquitectura de computadoras. Recuperado el 6 de Enero de 2010, de: http://iteso.mx/~jluis/acpdf/oto-04/12-Computadoras-RISC.PDF

Desconocido. (s.f.). Arquitectura de procesadores personales. Recuperado el 8 de Enero de 2010, de Sitio Web de la Facultad de Ciencias de la Administración de la Universidad Nacional de Entre Ríos: http://www.fcad.uner.edu.ar/_car/c_sis/sis06/unidad%206.ppt

Desconocido. (s.f.). RISC y CISC. Recuperado el 8 de Enero de 2010, de Itescam.edu: http://www.itescam.edu.mx/principal/sylabus/fpdb/recursos/r21845.DOC

División de Ciencias Básicas e Ingeniería de la UAM. (s.f.). Arquitectura RISC vs CISC. Recuperado el 13 de Enero de 2010, de Sitio Web de la Universidad Autonoma Metropolitana:

http://www.azc.uam.mx/publicaciones/enlinea2/num1/1-2.htmPalet, J. (s.f.). Procesadores RISC, multiproceso y caché. Recuperado el 5 de Enero de 2010, de

Consulintel.es: http://www.consulintel.es/html/Tutoriales/Articulos/risc.htmlMuro García, L. (21 de Noviembre de 2007). Arquitectura de Microprocesadores RISC y CISC.

Recuperado el 14 de Enero de 2010, de Monografías.com: http://www.monografias.com/trabajos55/microprocesadores-cisc-risc/microprocesadores-cisc-risc2.shtml

Procesadores Superescalares. (s.f.). Recuperado el 14 de Enero de 2010, de Angelfire: http://www.angelfire.com/ca6/germancho/superescalar.htm

Wikipedia. (3 de Enero de 2010). RISC. Recuperado el 8 de Enero de 2010, de Wikipedia, la enciclopedia libre: http://es.wikipedia.org/wiki/RISC

Wikipedia. (3 de Enero de 2010). ARM. Recuperado el 14 de Enero de 2010, de Wikipedia, la enciclopedia libre: http://es.wikipedia.org/wiki/ARM

Wikipedia. (1 de Enero de 2010). MIPS (procesador). Recuperado el 14 de Enero de 2010, de Wikipedia, la enciclopedia libre: http://es.wikipedia.org/wiki/MIPS_(procesador)

Wikipedia. (14 de Enero de 2010). OpenRISC. Recuperado el 14 de Enero de 2010, de Wikipedia, the free encyclopedia: http://en.wikipedia.org/wiki/OpenRISC

Wikipedia. (14 de Diciembre de 2009). Segmentación (informática). Recuperado el 14 de Enero de 2010, de Wikipedia, la enciclopedia libre: http://es.wikipedia.org/wiki/Segmentaci%C3%B3n_(inform%C3%A1tica)

Wikipedia. (17 de Noviembre de 2009). Segmentación de cauce. Recuperado el 14 de Enero de 2010, de Wikipedia, la enciclopedia libre: http://es.wikipedia.org/wiki/Segmentaci%C3%B3n_de_cauce

Wikipedia. (18 de Octubre de 2009). Sun SPARC. Recuperado el 14 de Enero de 2010, de Wikipedia, la enciclopedia libre: http://es.wikipedia.org/wiki/SPARC

Wikipedia. (19 de Noviembre de 2009). Superescalar. Recuperado el 14 de Enero de 2010, de Wikipedia, la enciclopedia libre: http://es.wikipedia.org/wiki/Superescalar