INTEGRANTES:

2010
Muñoz Aleman Jonathan
Ramos Ramírez Yaser
Universidad Nacional del Santa
13/01/2010

Exposición: Computadores
RISC
 Í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
Error: Reference source not found

Índice de Figuras

Figura 1. Microprocesadores CISC................................................................13

Figura 2. Microprocesadores RISC................................................................15
Figura 3. Programa de instrucciones en el Intel Pentium IV.........................18
Figura 4. Detalle de la segmentación de instrucciones................................18
Figura 5. Arquitectura Harvard....................................................................19
Figura 6. Cómo se conforma la segmentación de instrucción......................20
Figura 7. Ejecución de instrucciones en un procesador superescalar..........22
Figura 8. Organización de los procesadores superescalares........................22
 Figura 9. Organización de la microarquitectura de un procesador
superescalar.....................................................................................................23
Figura 10. Procesador ARM en una impresora HP........................................31
Figura 11. Sun UltraSparc II.........................................................................32
Figura 12. Un microprocesador MIPS R4400 fabricado por Toshiba.............33
Figura 12. Un microprocesador MIPS R4400 fabricado por Toshiba.
 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 hardware
Incluye el multi-reloj, instrucciones Solo-reloj, instrucciones complejas
reducida
Inter – registro: “CARGA” y Memoria a memoria: “CARGA” y
“ALMACÉN” incorporado en “ALMACÉN” son las instrucciones
instrucciones independientes
Altos ciclos por segundo, tamaños Ciclos bajos por segundo, tamaños de
de código pequeños código grandes
Transistores usados para Pasa más transistores en los registros de
almacenar instrucciones complejas la memoria

Conjunto de instrucciones

Instrucciones de carga/almacenamiento
OPERAN DESCRIPCIÓN
DO
LDSB Cargar byte con signo
LDSH Cargar media palabra
con signo
LDUB Cargar byte sin signo
LDUH Cargar media palabra sin
signo
LD Cargar palabra
LDD Cargar doble palabra
STB Almacenar byte
STH Almacenar media
palabra
 STD Almacenar palabra
STDD Almacenar doble palabra

Instrucciones de desplazamiento
OPERAN DESCRIPCIÓN
DO
SLL Desplazamiento lógico a la
izquierda
SRL Desplazamiento lógico a la
derecha
SRA Desplazamiento aritmético a la
derecha

Instrucciones Booleanas
OPERAN DESCRIPCIÓN
DO
AND Y
ANDCC Y, ajustar icc
ANDN No Y
ANDNCC No Y, ajustar icc
OR O
ORCC O, ajustar icc
ORN No O
ORNCC No O, ajustar icc
XOR O Exclusiva
XORCC O Exclusiva, ajustar
icc
XNOR No O Exclusiva
XNORCC No O Exclusiva,
ajustar icc

Instrucciones aritméticas
OPERAN DESCRIPCIÓN
DO
ADD Sumar
ADDCC Sumar, ajustar icc
ADDX Sumar con acarreo
ADDXCC Sumar con acarreo, ajustar
icc
SUB Restar
SUBCC Restar, ajustar icc
SUBX Restar con adeudo
SUBXCC Restar con adeudo, ajustar
icc
 MULSCC Paso de multiplicación,
ajustar icc

Instrucciones de salto/bifurcación
OPERAN DESCRIPCIÓN
DO
BCC Bifurcar si condición
FBCC Bifurcar si condición de coma
flotante
CBCC Bifurcar si condición del
procesador
CALL Llamar a procedimiento
JMPL Saltar y enlazar
TCC Interceptar si condición
SAVE Avanzar ventana de registros
RESTORE Mover ventanas hacia atrás
RETT Retornar de interceptación

Instrucciones diversas
OPERAN DESCRIPCIÓN
DO
SETHI Fijar los 22 bits altos
UNIMP Instrucción no implementada
(Interceptación)
RD Leer un registro especial
WR Escribir en un registro especial
IFLUSH Vaciar la caché de instrucciones

CUADRO COMPARATIVO

CISC RISC

Una instrucción por Pequeñas instrucciones.

circunstancia.

Instrucciones complejas. Instrucciones simples.

Lenta ejecución de la Ejecución rápida de las

instrucción. instrucciones.

Pocas instrucciones por Varias instrucciones por trabajo

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

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

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

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:
○ Transferencia.
○ Operaciones.
○ 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: ()

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

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

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

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

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úsqueda
ID: decodificación
EX: ejecución de unidad aritmética lógica
MEM: memoria
WB: 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. ()

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°
1 2 3 4 5 6 7 8 9 10
CICLO

ME
Instr. 1 IF ID EX WB
M

ME
Instr. 2 IF ID EX WB
M

ME
Instr. 3 IF ID EX WB
M

ME
Instr. 4 IF ID EX WB
M

ME
Instr. 5 IF ID EX WB
M

ME
Instr. 6 IF ID EX WB
M

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

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

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 ():
 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 ():

•
• 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 ():

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

1. La decodificación paralela y el uso de predecodificación

2. La emisión paralela de instrucciones a las unidades funcionales
3. 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 ():

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

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

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

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:
○ Inmediato, (constantes de 13 bits).
○ Directo, (offset de 13 bits).
○ Indirecto, (registro + offset de 13 bits o registro + registro).
• Utiliza instrucciones retardadas (saltos, load y store ).
• Manejo de memoria:
○ Espacio virtual de 4 Gigabytes.
○ 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. ()

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.htm
Palet, 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.html
Muro 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