Risc y Sics

Arquitectura de CPUs avanzadas.
Juegos CISC i RISC, proceso paralelo, procesadores escalares y vectoriales, pipeline, cachs multinivel
Arquitectura de CPUs avanzadas. Juegos CISC i RISC, proceso paralelo, procesadores escalares y vectoriales, pipeline, cachs multinivel
ndice de contenido
Arquitectura de CPUs avanzadas. Juegos CISC i RISC, proceso paralelo, procesadores escalares y vectoriales, pipeline, cachs multinivel.........................................................................................................1 Licencia......................................................................................................................................................1 Tcnicas avanzadas....................................................................................................................................1 Microprogramacin................................................................................................................................1 Segmentacin.........................................................................................................................................2 Superescalaridad.....................................................................................................................................4 Procesamiento vectorial.........................................................................................................................6
Evaluacin del rendimiento................................................................................................................................8 Tcnicas avanzadas.............................................................................................................................................8
CISC vs RISC...........................................................................................................................................10 Memorias cach.......................................................................................................................................11 Asociativas...........................................................................................................................................12 De correspondencia directa..................................................................................................................13 Asociativas por conjuntos....................................................................................................................13 Jerarquas de cach...............................................................................................................................14 Tecnologas futuras..................................................................................................................................15 Procesadores multincleo.....................................................................................................................15 Procesadores asncronos.......................................................................................................................15 Lgica reprogramable...........................................................................................................................15 Computacin cuntica..........................................................................................................................16
Licencia
Este obra de Jess Jimnez Herranz est bajo una licencia Creative Commons AtribucinLicenciarIgual 3.0 Espaa. Basada en una obra en oposcaib.wikispaces.com.
Tcnicas avanzadas
Microprogramacin
La unidad de control de una CPU es el circuito encargado de coordinar a todas las unidades funcionales del procesador. En las primeras CPUs, la UC se diseaba como un circuito secuencial, lo que haca que, conforme aumentaba el nmero de instrucciones y su complejidad, se hiciese ms difcil su diseo. De la misma manera, en caso de detectarse un error en la implementacin de una instruccin, corregir el problema era una tarea complicada y costosa. Para aliviar este problema, se desarrollaron las unidades de control multiprogramadas. La multiprogramacin es una tcnica que consiste en considerar la ejecucin de una instruccin de la CPU como una serie de pasos, en el que cada uno de ellos est representado por el estado de las seales de control de las diferentes unidades funcionales de la CPU. As, si a este conjunto de seales en un momento dado le llamamos microinstruccin, la ejecucin de una instruccin consistir simplemente en ejecutar secuencialmente una serie de microinstrucciones, obteniendo as un microprograma. Extrapolando esto a toda la CPU, es posible implementar el juego de instrucciones de una CPU mediante un microprograma. El esquema bsico de funcionamiento sera parecido al siguiente:
Jess Jimnez Herranz, http://oposcaib.wikispaces.com 1
Estado ALU
MUX +
PC
ROM ...
Seales de control
Las microinstrucciones se almacenan en una ROM (que puede ser RAM para facilitar la actualizacin), de manera que cada bit de la microinstruccin representa una seal de control de alguna unidad funcional. La microinstruccin que se ejecuta en un momento dado ser la que indique el registro microPC, y la determinacin del valor de este registro la har el micromultiplexor, considerando tanto la microinstruccin actual, como el estado de la ALU u otras informaciones que pueda haber encapsuladas en la propia microinstruccin (por ejemplo en el caso de una microinstruccin de salto). Dependiendo de cmo se estructuren las microinstrucciones, se puede hablar de dos tipos de microprogramacin:

Horizontal: Cada bit de una microinstruccin es una seal de control Vertical: Bits relacionados se compactan. Por ejemplo, la entrada de un codificador se puede guardar como un nmero entero.
La microprogramacin horizontal obliga a usar mayor cantidad de memoria al generar microprogramas ms grandes, aunque es ms rpida que la vertical, que obliga a aadir circuitera adicional para decodificar las partes compactadas. En diseos complejos, con microinstrucciones muy grandes, es posible aadir un nivel adicional de indireccin, guardando en una memoria aparte las microinstrucciones y almacenando en micromemoria nicamente las referencias. Esto se conoce como nanoprogramacin, y permite reducir drsticamente el tamao del microprograma, al coste de reducir ms an el rendimimiento. La principal ventaja de la multiprogramacin es que facilita enormemente el diseo de CPUs, al poder implementar su juego de instrucciones de una forma sencilla. Adems, si el microprograma se guarda en una memoria actualizable, es posible corregir errores de implementacin, actualizar a versiones ms eficientes o incluso cambiar el juego de instrucciones de una forma muy sencilla. El principal problema es el rendimiento, ya que se aade un nivel de indireccin adicional que ralentiza el funcionamiento. En cualquier caso, si el juego de instrucciones es complejo, generalmente compensa la prdida de rendimiento a cambio de la facilidad de diseo.
Segmentacin
Tradicionalmente, la ejecucin de una instruccin se divide en una serie de etapas: lectura de memoria o fetch (F), decodificacin (D), ejecucin (E) y almacenamiento de resultados (M). En un diseo de CPU clsico, las instrucciones se ejecutan una por una, de manera que hasta que una instruccin no ha terminado de ejecutarse no se comienza con la siguiente. Esto provoca que gran
parte de la circuitera de la CPU (la correspondiente a las etapas distintas de la actual) se encuentre ociosa en un momento dado. La segmentacin es una tcnica que consiste en solapar la ejecucin de instrucciones consecutivas. Para ello, separa el procesamiento de una instruccin en una serie de etapas separadas (el pipeline), permitiendo que dos o ms instrucciones se ejecuten a la vez siempre y cuando estn en etapas diferentes. El siguiente diagrama muestra de una manera grfica el resultado de usar segmentacin:
Sin segmentacin F D E M F D E M F D E M
12 ciclos
Con segmentacin F D E M F D E M F D E M
6 ciclos
Se puede observar como la segmentacin proporciona una aceleracin al rendimiento notable, alcanzndose un rendimiento de pico de 1 instruccin por ciclo. Ahora bien, algunas circunstancias pueden impedir llegar a este rendimiento ideal. En primer lugar, si una instruccin tiene un tiempo de ejecucin especialmente lento (p. ej. una divisin) bloquear al resto de instrucciones del pipeline hasta que acabe. Por otra parte, las instrucciones de salto condicional afectan especialmente al rendimiento, ya que no se puede determinar cul es la siguiente instruccin hasta que se ha calculado la direccin del salto. La siguiente figura muestra estos efectos:
Instruccin lenta F D E M
divisin
Salto F D E M F D E M F D E M
salto
F D E E E E M F D E M
El problema de las instrucciones lentas no tiene solucin, y adems se ve aliviado mediante tcnicas como la superescalaridad. Por el contrario, para el problema de los saltos condicionales s se pueden aplicar diferentes tcnicas para aliviarlo:
Prediccin de salto: Consiste en tratar de adivinar cul va a ser el salto antes de calcular la direccin, y continuar la ejecucin. Para ello hay muchas maneras: las ms sencillas consistiran en asumir siempre que se va a saltar (o que no), o decidir si se va a saltar o no en funcin de la direccin del salto. Dado que gran parte de los saltos condicionales forman parte de un bucle, y en un bucle el salto suele ser efectivo ms del 90% de las veces, mediante estas tcnicas se puede predecir el salto con bastante fiabilidad. Tcnicas ms complejas implican mantener tablas de estadsticas para cada direccin, guardando la historia sobre la direccin del salto en instrucciones anteriores. As mismo, tambin es posible combinar diferentes tcnicas y resolverlo por votacin.
Resolucin previa: No esperar a llegar a la instruccin de salto para resolverlo. Si se detecta un salto en el futuro (y no hay dependencias que lo impidan), cambiar el orden de las instrucciones para ir calculando el salto y disponer ya de la direccin destino cuando haga falta. Branch predication: Plantear el juego de instrucciones de manera que no existan saltos, sino que cada instruccin incorpore una condicin, que har que se ejecute o no. Es un esquema que mejora mucho el rendimiento, pero es costoso a nivel de tamao del opcode. Optimizaciones del compilador: En la fase de compilacin del programa es posible realizar anlisis sobre la probabilidad de tomar cada salto, que se pueden incorporar luego al propio opcode de la instruccin. Otra forma de mejorar el rendimiento del cdigo es generar saltos ms sencillos y por tanto fciles de calcular. Por ejemplo, saltar si x>=10 es un salto ms complejo (requiere hacer una resta) que saltar si x=10 (slo requiere una comparacin).
Con las tcnicas anteriores, es posible llegar a una tasa de prediccin de salto de cerca del 100%. No obstante, en ocasiones no es posible predecir correctamente el salto, en cuyo caso, adems de la prdida de paralelismo, hay un tiempo de penalizacin debido a que hay que vaciar el pipeline y eventualmente deshacer algn cambio que pudiera haber hecho una instruccin predicha errneamente. As, el tiempo de ejecucin promedio de una instruccin sera: Tmedio=1Psalto 1P salto P acierto 1T penalizacin 1P acierto 1 Donde P salto es la probabilidad de que la instruccin sea un salto, Pacierto es la probabilidad de acertar en la prediccin y T penalizacin es el tiempo extra de penalizacin en caso de fallar la prediccin.
Superescalaridad
Si la segmentacin busca ejecutar ms de una instruccin a la vez solapando aquellos momentos en que dos instrucciones usan diferentes unidades funcionales, la superescalaridad va ms all, y consiste en proporcionar ms unidades funcionales de las necesarias para poder ejecutar ms de una instruccin simultneamente. Generalmente, la superescalaridad suele ir de la mano de la segmentacin, ya que son tcnicas que se complementan. Dado que en una CPU superescalar hay ms recursos de los estrictamente necesarios, interesa maximizar el nmero de instrucciones simultneamente en ejecucin para conseguir el mayor paralelismo posible. Para ello, una tcnica comn es no respetar el orden de las instrucciones en el programa, lanzndolas a ejecucin en desorden para evitar cuellos de botella y maximizar el paralelismo. Existen diferentes esquemas:

Lanzamiento y finalizacin en orden: Muy lento, impide alcanzar un buen grado de paralelismo. Lanzamiento sin orden, finalizacin en orden: El ms usado Lanzamiento y finalizacin sin orden: No tiene mucho sentido, los datos no seran coherentes.
Al ejecutar las instrucciones en un orden diferente al del programa sin mayores precauciones, es posible que los resultados finales no sean los deseados. Para ello, hay que tener en cuenta las dependencias entre las diferentes instrucciones, respetndolas para producir resultados correctos. Concretamente, existen tres tipos de dependencias:
Jess Jimnez Herranz, http://oposcaib.wikispaces.com

RAW (Read After Write): Sucede cuando una instruccin de lectura espera el resultado de una instruccin de escritura anterior. WAR (Write After Read): Si una instruccin escribe en un lugar ledo por una instruccin anterior, y se altera el orden, es posible que los resultados no sean correctos. Tambin se conocen como antidependencias (son como las RAW, pero al revs). WAW (Write After Write): Si dos instrucciones que escriben en el mismo sitio son cambiadas de orden, los resultados pueden no ser correctos. Tambin se conocen como dependencias de salida.
Las dependencias RAW son dependencias reales, que ya existen en la ejecucin en orden y no pueden ser resueltas ms que esperando a que el resultado est disponible. Por tanto, un procesador superescalar debe detectarlas y no ejecutar la lectura hasta que la escritura est disponible. Las dependencias WAR y WAW, por otra parte, se conocen como virtuales y son exclusivas de la ejecucin sin orden, y pueden ser resueltas mediante el uso de diferentes tcnicas. De esta manera, al eliminar dependencias es posible lanzar ms instrucciones simultneamente y mejorar por tanto el rendimiento. La principal tcnica para solucionar las dependencias virtuales es el renombre de registros. Mediante esta tcnica, cada vez que se escribe en un registro se crea una copia del mismo (se renombra) y se contina usando esta copia, eliminndose por tanto estas dependencias. El siguiente ejemplo muestra el funcionamiento del renombre de registros y cmo permite eliminar dependencias virtuales y aumentar el paralelismo o grado de superescalaridad:
RAW WAR RAW RAW
1 2 3 4 5
ADD R1,2 ST #46,R1 LD R1,#66 ADD R1,4 ST #70,R1
Renombre
RAW RAW RAW
1 2 3 4 5
ADD R1,2 ST #46,R1 LD R1,#66 ADD R1,4 ST #70,R1
Orden: 1 2 3 4 5 5 ciclos
Orden: 1 2 5 3 4 3 ciclos
Una forma de implementar el renombre de registros es mediante el uso de estaciones de reserva. Una estacin de reserva es un buffer en el que se insertan las instrucciones lanzadas, a la espera de ser ejecutadas. Para cada instruccin se guarda su opcode, as como informacin de sus operandos: si ste se encuentra disponible, se guarda el valor, y si no lo est porque su valor depende del resultado de otra instruccin, se almacena la referencia a la posicin de la estacin de reserva de la instruccin de la que se depende. A la hora de lanzar instrucciones a ejecucin, se buscan en la estacin de reserva instrucciones que tengan todos sus operandos disponibles y, de la misma manera, al acabar la ejecucin se actualizan correspondientemente los operandos de las instrucciones que estn a la espera. Para mantener actualizados los registros, se mantiene una tabla adicional que indica, para cada registro de la CPU, qu posicin de la ER almacena la instruccin que generar su valor. Un esquema de este funcionamiento sera el de la siguiente figura:
Pos Opcode 1 2 3 4 5 ADD ST LD ADD ST
Operando 1 S No No No ? 1 3 4 S S
Operando 2 2 4 -
Mem Reg #46 #66 #70 R1 ... ER 4 ...
Listo Valor Ref ER Listo Valor Ref ER
De esta manera, al empilar una instruccin en una ER, pasa a depender de los propios valores almacenados en la misma, por lo que el renombre de registros se hace de forma implcita. Para asegurar que las instrucciones finalizan en orden, se usa el buffer de reorden (ROB), en el que se van introduciendo las instrucciones a medida que son lanzadas:
Instr Flag ADD 1 ST LD ST ... 0 1 0
ADD 0
Cada instruccin tiene asociado un flag, que indica si la instruccin ha sido ejecutada o no. Cuando una instruccin acaba, se consulta el ROB, y slo se escriben sus resultados si todas sus instrucciones predecesoras han acabado tambin. De esta manera, y combinado con el renombre de registros que se hace en la estacin de reserva, se evitan resultados no deseados en dependencias WAR o WAW. En realidad, aqu slo se muestra una posible solucin al problema de la resolucin de dependencias en procesadores superescalares. Existen numerosas formas de afrontarlo, como por ejemplo guardar los operandos (y hacer por tanto el renombre de registros) en el ROB en lugar de en la estacin de reserva, disponer de varias estaciones de reserva (una por unidad funcional) en vez de una nica estacin, etc.
Procesamiento vectorial
En la ejecucin de un programa, gran parte del tiempo se dedica a leer instrucciones de memoria y decodificarlas. En algunos mbitos en los que se opera con un gran nmero de datos, como el clculo cientfico, esto puede ser un problema importante de rendimiento, por lo que una forma de acelerar el funcionamiento es procesar ms de un dato por instruccin. Este es el principio de los procesadores vectoriales.
Un procesador vectorial permite operar sobre un cierto conjunto de datos en cada instruccin. Generalmente se trabaja con vectores de datos, pero nada impide hacerlo con matrices, o cualquier otra organizacin de datos multidimensional. Ventajas:

Cdigo ms compacto Eliminacin de dependencias: Las operaciones que se realizan dentro de una misma instruccin son por definicin independientes entre s, por lo que son fcilmente paralelizables.
Inconvenientes:

Necesario gran ancho de banda de memoria No es un esquema de propsito general: Si bien algunas aplicaciones son muy fcilmente vectorizables, no todos los problemas se adaptan a este esquema.
Histricamente, se han desarrollado diferentes tipos de procesadores vectoriales:

Procesadores matriciales asociados
CPU no vectorial
Bus 1 Bus 2
Arquitecturas memoriamemoria
CPU vectorial
Procesadores con registros vectoriales

CPU vectorial
R1 R2
...
PM1 ... PMn M1 ... Mn
Rn
En este esquema, se dispone de una CPU no vectorial, conectada a una serie de procesadores vectoriales. El programa se encarga de programar correctamente estos procesadores. El gran problema de este esquema es que el bus constituye un cuello de botella del sistema.
En este esquema se trabaja con una CPU vectorial, que accede a la memoria. Para evitar cuellos de botella, se dispone de varias memorias y ms de un bus. Este sistema, adems de ser costoso, requiere organizar cuidadosamente los datos, de forma que los datos de una misma operacin estn en memorias diferentes o se puedan acceder con diferente bus.
Este esquema emula a una CPU convencional, con la diferencia de que en este caso los registros son vectores. De esta manera la forma de trabajar es ms parecida a la programacin en una CPU no vectorial, y se genera un cdigo ms compacto y ms fcil a la hora de resolver dependencias.
El esquema ms utilizado es el de registros vectoriales, ya que permite tener controlado el ancho de banda de memoria, y la tecnologa de CPUs actual permite disponer de registros vectoriales internos de un tamao considerable. La programacin en este esquema es muy similar al concepto Load/Store de las CPUs RISC, y consistira en cargar inicialmente los datos a procesar en alguno de los registros vectoriales, y luego operar sobre ellos, para finalmente almacenar los resultados en memoria. De esta forma slo se genera trfico en el bus al principio y al final de cada operacin. Un programa tpico que
multiplicase un vector por un valor y luego lo sumase a otro vector podra ser el siguiente, mostrado en cdigo convencional y en su equivalente vectorial:
Cdigo no vectorial
MOV #23,R1 MOV #90,R2 MOV #150,R3 MOV 10,R4 bucle: LD R1,R5 LD R2,R6 MUL R5,5,R7 ADD R7,R6,R8 ST R8,R3 SUB R4,1,R4 JNZ bucle
Cdigo vectorial
LD #23,V1 LD #90,V2 MUL V1,5,V3 ADD V1,V3,V4 ST V4,#150
Como se puede ver, la reduccin en tamao de cdigo es notable. Evaluacin del rendimiento Generalmente, y aprovechando la ausencia de dependencias en las operaciones internas de una misma instruccin, las unidades funcionales de un procesador vectorial son segmentadas. As, el rendimiento de una operacin vectorial para un tamao de vector n sera: T ejecucin=T inicializacinn1 V iniciacin donde T inicializacin sera el tiempo que transcurre hasta el primer resultado, y V iniciacin sera el tiempo entre dos resultados. Tomando el cdigo de ejemplo del apartado anterior, y suponiendo que una suma tarda 2 ciclos, una multiplicacin 5, una operacin de memoria 3, y una asignacin 1 ciclo, el tiempo de ejecucin de la versin no vectorial sera: T ejecucin=T inicializaciones n T bucle=3TMOV n 2T LD T MULT ADDT ST =16n3 Es importante destacar que el hecho de que la CPU escalar sea o no segmentada no afecta apenas al clculo, ya que el cdigo presenta dependencias irresolubles que impediran una gran aceleracin. As, para un n de 64 posiciones el tiempo de ejecucin sera de 1027 ciclos. Por su parte, el rendimiento de la versin vectorial, suponiendo unidades funcionales segmentadas de 2 y 5 ciclos de tiempo de iniciacin para suma y multiplicacin respectivamente, sera: T vectorial =2 T LDT MULT ADDT ST =6n5n1 2 n13n=11n5 Para n=64, el tiempo de ejecucin sera de 709 ciclos, lo cual supone cerca de un 50% de mejora respecto a la versin escalar. Esta mejora se consigue principalmente mediante la eliminacin de las dependencias que proporciona el funcionamiento vectorial, consiguindose as una ejecucin segmentada sin detenciones. Tcnicas avanzadas Existen diferentes tcnicas para acelerar ms el rendimiento de los procesadores vectoriales basados en registros. Una de ellas es el encadenamiento, que consiste en conectar directamente la salida de una unidad funcional a la entrada de otra. Esto slo puede hacerse si se cumplen tres condiciones:

Instrucciones consecutivas utilizan diferentes unidades funcionales Existe una dependencia real (RAW) entre una instruccin y la anterior El rendimiento de la primera unidad funcional es igual o menor al de la segunda
Si se cumplen estas condiciones, se pueden encadenar las dos instrucciones, de manera que se ejecutan en paralelo y prcticamente en el mismo tiempo (el de la operacin ms lenta). Mediante el uso de este esquema, las dependencias de datos se vuelven deseables en vez de ser algo a evitar o resolver. En el ejemplo del apartado anterior, las instrucciones de multiplicacin y suma son encadenables, ya que son consecutivas, usan diferentes unidades funcionales, la segunda depende de la primera y la multiplicacin es ms lenta que la suma. As, la ejecucin de estas dos instrucciones se podra mostrar grficamente de la siguiente forma:
M1 M1 M1 M1 M1 M2 M3 M4 M5 M6 M7 ... Mn-1 Mn A1 A1 A2 A3 A4 A5 ... An-3 An-2 An-1 An
Por tanto, el tiempo del conjunto multiplicacin-suma, que antes era de: T MUL ADD=T MUL T ADD=5n12n1=2n5 ahora ser de: T MUL ADD=T MUL n1V iniciacinT ADD=5n12=n6 por lo que el tiempo total sera ahora: T ejecucin=2T LDT MUL ADDT ST =6nn63n=10n6 Para n=64, ahora el tiempo de ejecucin es de 646, lo cual duplica ya al rendimiento de la versin escalar. Examinando estos ejemplos, se observa como la mayor parte del tiempo lo ocupan los accesos a memoria. Existen formas de organizar la memoria de manera que se optimicen los accesos. Para ello, hay que tener en cuenta la estructura de una memoria, que bsicamente es algo as:
Direccin
D0 D4 D8 . . . Dn-3
D1 D5 D9 . . . Dn-2
D2 D6 D10 . . . Dn-1
D3 D7 D11 . . . Dn
Dato
Esta sera una memoria entrelazada de 4 vas. En esta memoria, los datos estaran divididos en 4 bloques, cada uno de ellos con un registro asociado. La particularidad de estas memorias es que, al llegarles una peticin de un dato, devuelven el solicitado, pero tambin buscan los datos cercanos y los guardan en los registros de cada banco. De esta manera, si en posteriores accesos se solicitan datos cercanos (probable segn el principio de localidad), ya estn calculados y se pueden devolver inmediatamente.
En el caso de los procesadores vectoriales, que trabajan con vectores o matrices, es importante organizar correctamente los datos en memoria para obtener el mximo rendimiento. As, la organizacin que se muestra en el diagrama anterior es la idnea para recorrer los datos linealmente, por lo que se optimizara el acceso por filas a una matriz. Si quisiramos recorrerla de formas diferentes, sera deseable organizar los datos de forma diferente:
Acceso por filas Acceso por columnas
D0 D4 D8 D12
D1 D5 D9 D13
D2 D6 D10 D14
D3 D7 D11 D15
D0 D1 D2 D3
D4 D5 D6 D7
D8 D9 D10 D11
D12 D13 D14 D15
Otra tcnica comn para mejorar el rendimiento de los procesadores vectoriales es la compactacin de vectores. Esta tcnica es aplicable cuando se utilizan vectores dispersos, es decir, aquellos en los que slo se utilizan algunas de las posiciones, o en los que gran parte de las posiciones tienen el mismo valor. En estos casos se dispone de instrucciones especiales para compactar los vectores, de manera que ocupen menos tamao. Esto tiene varias consecuencias: en primer lugar se aprovecha mejor el espacio en la CPU, y por otra parte se evita realizar un gran nmero de clculos innecesarios.
CISC vs RISC
En los primeros computadores, la programacin se realizaba exclusivamente en lenguaje ensamblador. Por ello, los juegos de instrucciones tenan una serie de caractersticas para facilitar la programacin:

Gran nmero de instrucciones Instrucciones complejas: P. ej., multiplicaciones o divisiones. Mltiples modos de direccionamiento Ortogonalidad: Poder utilizar cualquier registro y modo de direccionamiento con cualquier instruccin.
Conforme las CPUs fueron evolucionando, esta tendencia continu, por lo que el diseo de las unidades de control se fue haciendo ms complejo y oblig al desarrollo de tcnicas como la multiprogramacin, que aunque facilitabal el diseo de las UC, tambin aadan una complejidad importante a las CPUs. A finales de los 70, y con el auge ya de los lenguajes de alto nivel, se observ que los compiladores no utilizaban ms que un pequeo subconjunto de las instrucciones de los procesadores, por lo que tal vez se podran plantear diseos ms simples que simplificasen la unidad de control y destinasen los recursos a otros aspectos que diesen lugar a diseos ms eficientes. Al mismo tiempo, las CPUs se estaban volviendo ms rpidas que las memorias, por lo que se haca importante maximizar el trabajo con registros en contraposicin a acceder a la memoria prcticamente en cada instruccin. En esta situacin surgi el trmino RISC (Reduced Instruction Set Computer) en contraposicin al clsico diseo CISC (Complex Instruction Set Computer). Aunque el nombre pueda dar a
10
entender que el cambio se limita al tamao del juego de instrucciones, el paradigma va mucho ms all, y se caracteriza por los siguientes puntos:
Arquitectura Load/Store: Las instrucciones slo pueden operar con registros, excepto las especialmente designadas para leer y escribir de memoria. De esta manera se maximiza el uso de los registros. Simplificacin de las instrucciones: Se eliminan la mayora de modos de direccionamiento, y no se incluyen en la CPU instrucciones complejas que puedan implementarse en funcin de otras ms simples. El formato de instruccin es fijo. Unidad de control muy simple: No usar microprogramacin. Implementar predicciones de salto muy sencillas.
Los objetivos de RISC son:

Disminuir el tiempo de proceso de cada instruccin para aumentar la frecuencia de funcionamiento y la eficiencia de la segmentacin. Minimizar los accesos a memoria. Liberar recursos hardware que puedan ser usados para otras tareas ms productivas. Mover la complejidad de muchas tareas (prediccin de salto, implementacin de operaciones complejas) a los compiladores.
Al simplificar en gran medida la unidad de control, quedan disponibles recursos hardware que se pueden usar para otras tareas:
Ms registros: De esta manera se pueden reducir an ms los accesos a memoria. Tambin sirven para otras cosas, como por ejemplo usarlos para el paso de parmetros en las llamadas a subrutina en vez de usar el stack de memoria (ventana de registros). Ms unidades funcionales: Permiten aumentar el nivel de superescalaridad. Incluir cach en la propia CPU: Adems de una aceleracin general, reducen las paradas del pipeline en CPUs segmentadas.
A da de hoy, prcticamente todos los diseos de CPUs siguen la filosofa RISC, si bien en ocasiones combinan elementos de ambos paradigmas (p. ej. CPUs RISC con instrucciones SIMD para manejo de vectores claramente CISC). Incluso arquitecturas completamente CISC, como la 80x86, funcionan internamente como una CPU RISC, aunque para mantener la compatibilidad de cdigo se introduce un mdulo extra que traduce el juego de instrucciones CISC a un cdigo interno RISC.
Memorias cach
Aunque en los inicios de la computacin la velocidad de CPUs y memoria era similar, conforme ha pasado el tiempo la diferencia entre unas y otras se ha hecho mayor, y a da de hoy una CPU funciona a una velocidad varios rdenes de magnitud por encima de la de la memoria. Esto hace que los accesos a RAM supongan una ralentizacin muy importante para la ejecucin de cdigo, por lo que se hace necesario algn mecanismo que, por lo menos, suavice el problema. As, las memorias cach son memorias de gran velocidad y pequeo tamao que se sitan entre la CPU y la RAM, de manera que almacenan los valores ms usados de la memoria con la intencin de evitar los accesos a RAM lo mximo posible. As, en cada acceso a memoria de la CPU se consulta en primer lugar si el dato se encuentra en cach. Si es as, se devuelve directamente a la
11
CPU, mientras que si no est se lee de memoria, se devuelve a la CPU, y se inserta en cach previendo accesos futuros. La idea de la memoria cach se basa en los principios de localidad:

Localidad temporal: Es probable que en el futuro cercano se utilicen los mismos datos que en el momento actual. Localidad espacial: Es probable que instrucciones consecutivas utilicen datos cercanos
Al mantener dos copias de los datos (una en cach y otra en la RAM), es importante tener sincronizadas ambas memorias, de manera que no se produzcan incoherencias. Existen dos esquemas de escritura de cach:

Write-through: Al escribir en cach, se actualiza inmediatamente la RAM. Es poco eficiente (genera ms trfico en el bus) pero ms seguro a la hora de evitar coherencias. Write-back: No escribir los cambios a RAM hasta sacar el bloque de la cach. Rpido pero arriesgado.
A continuacin se muestran diferentes esquemas para organizar los datos dentro de una cach.
Asociativas
Una cach asociativa tiene la siguiente estructura:
Direccin:
Tag Offset
Vlido
Tag (M bits)
Bloque de datos (2N posiciones)
1 0 0 1 0 ...
Por tanto, la cach se organiza en bloques que contienen una copia de un fragmento de la memoria RAM (indicado por el tag). Cuando se hace una lectura a RAM, se determina el tag de la direccin y se mira si est en la cach buscando si hay un bloque con ese tag. Si est, se calcula el offset deseado, se lee de la cach y se devuelve. Si no, se carga en cach el bloque entero correspondiente al tag solicitado en previsin de posibles accesos. Si bien este esquema es muy eficiente, tambin es el ms costoso en cuanto a circuitera, ya que requiere comparar el tag de la direccin con todos los tags activos de la cach simultneamente, lo cual hace que se deba incluir un comparador por cada posicin de cach. Por ello, slo se utiliza en cachs muy pequeas y en las que el rendimiento es fundamental (como p. ej. el TLB que se utiliza en esquemas de memoria virtual para acelerar la paginacin).
12
De correspondencia directa
Para evitar las grandes necesidades de hardware de las cachs asociativas, las cachs de correspondencia directa utilizan un esquema de hashing a partir de la direccin:
Direccin:
Tag Slot Offset
Vlido
Tag
Datos
1 0 0 1 0 ...
En este caso, se utilizan los bits menos significativos de la direccin como clave de hash que determina la posicin en la cach. As, para averiguar si una direccin est en cach basta comprobar si su slot est ocupado. Para evitar colisiones con direcciones diferentes que tengan el mismo slot, en el bloque de cach se guarda tambin el resto de la direccin. Si bien estas cachs son rpidas y simples, tiene el problema de que se desaprovecha mucho espacio debido a las colisiones. As, si dos direcciones diferentes son accedidas frecuentemente y coinciden en que tienen el mismo slot, estarn continuamente entrando y saliendo de cach a pesar de que quede espacio libre en la misma. Al desaprovechar el espacio, la probabilidad media de encontrar el valor en cach (hit ratio) es menor que en las asociativas.
Asociativas por conjuntos

Una forma de conseguir un punto medio entre el bajo coste de las cachs de correspondencia directa y el aprovechamiento del espacio de las asociativas son las cachs asociativas por conjuntos:
Conjunto 1 Conjunto 2
Tag
Datos
Tag
Datos
Al igual que en los esquemas de hash se establecen mecanismos para tolerar colisiones, en estas cachs se dispone de varios conjuntos de datos, de manera que si al insertar un dato ya hay otro con
13
el mismo slot, se dispone de conjuntos de datos alternativos en el que insertarlo. El diagrama anterior sera una cach asociativa de 2 vas. Este esquema tiene mejor hit ratio que las cachs de correspondencia directa al aprovechar mejor la memoria en caso de colisiones. La complejidad hardware es algo superior, ya que se aade el paso adicional de comparar el tag de la direccin con los de cada conjunto, para determinar cul de ellos es el que corresponde.
Jerarquas de cach
Como existen diferentes tipos de cach, cada uno con un coste y un rendimiento, una tcnica utilizada comnmente es utilizar diferentes cachs, de diferentes tipos y tamaos, formando una jerarqua:
CPU
L1
L2
L3
RAM
De esta manera, se podra utilizar una cach asociativa pequea como cach de nivel 1, y para la L2 y L3 utilizar cachs asociativas por conjuntos o de correspondencia directa. Las jerarquas de cach pueden ser de dos tipos:
Inclusiva: Los datos de las cachs inferiores (ms pequeas) se incluyen dentro de las de niveles superiores, es decir, L1 est en L2, etc. Se desaprovecha el espacio, pero es ms sencillo de gestionar. Exclusiva: Todas las cachs son independientes. Mejor aprovechamiento del espacio, pero la gestin se vuelve ms compleja cuando hay un fallo de cach.
Si, por ejemplo, suponemos la siguiente jerarqua de cach:

Memoria Hit ratio Tacceso L1 L2 RAM 96% 92% 3 10 50
El tiempo promedio de acceso a memoria ser: T accesoL1L2 =P L1 31P L1 P L2 101P L2 50=3.41 ciclos
Si, por el contrario, slo tuvisemos una nica cach L1, aunque fuese un ciclo ms rpida, el tiempo sera: T accesoL1 =P L1 21P L1 50=3.92 ciclos que es peor que el de la jerarqua. Lo mismo pasara con una sola cach L2, supongamos que de 8 ciclos: T accesoL2 =P L2 81P L2 50=11.36 ciclos Por tanto, combinar cachs en una jerarqua permite obtener buenos rendimientos a un coste razonable.
Tecnologas futuras
Procesadores multincleo
Una tendencia actual en el diseo de CPUs es integrar ms de una CPU en el mismo circuito, obteniendo as el equivalente a un ordenador multiprocesador pero con la velocidad aadida que proporciona la alta integracin. Si bien los diseos actuales integran no ms de 4 ncleos por procesador, la tendencia es al alza, y ya se habla de diseos con 8, 16 o ms procesadores. Esto representa un cambio de filosofa importante en lo que respecta a la forma de escribir los programas, ya que ser necesario adaptarse a estos diseos para aprovechar el alto nivel de paralelismo que traen implcitos este tipo de procesadores.
Procesadores asncronos
Una lnea de diseo con mucho potencial es la de las CPUs asncronas, que se caracterizan por no regirse por un reloj. De esta manera, las diferentes unidades funcionales se sincronizaran entre ellas, indicndose en cada momento cundo han acabado de calcular un dato o cuando pueden recibir ms. De esta manera, se puede conseguir el mximo rendimiento posible de un circuito, puesto que en los circuitos sncronos el periodo del reloj se debe establecer obligatoriamente segn el tiempo del componente ms lento, lo que provoca que muchos mdulos se encuentren inactivos durante gran parte del tiempo de reloj. El problema de los procesadores asncronos es que abren todo un campo de investigacin sobre la mejor manera de comunicar el estado de cada unidad funcional. As, una de las soluciones consiste en usar un sistema ternario para los datos, de manera que, adems del 0 y 1, se use otro valor que indique no preparado. En cualquier caso, es una tecnologa prometedora que, a pequea escala, ya comienza a dar frutos.
Lgica reprogramable
Otro campo de investigacin prometedor es el de la lgica programable, que tericamente permitira alterar la arquitectura de la CPU en tiempo real, adaptndose al programa que se est ejecutando. As, se contara con un nmero determinado de recursos de circuitera (puertas lgicas, etc.) que se distribuiran en cada momento de la forma ms apropiada: p. ej., si en un momento dado se est ejecutando un programa de clculo intensivo, se programara la CPU para que dispusiese de un alto nmero de unidades funcionales de clculo, mientras que si a continuacin para a ejecutar un programa general que use mucho la memoria, se podra habilitar un nmero mayor de registros o una cach ms grande. El hardware para implementar este esquema ya existe hoy en da, si bien el principal problema es el tiempo necesaro para la reprogramacin, que actualmente est en torno a los milisegundos y que hace inviable este tipo de diseos. No obstante, en el momento en que la velocidad de
reprogramacin est a niveles usables, ser posible construir CPUs con un rendimiento sensiblemente superior a las actuales.
Computacin cuntica
La computacin cuntica consiste en aprovechar las cualidades fsicas derivadas de la fsica cuntica para aumentar la capacidad de proceso de los ordenadores en varios rdenes de magnitud respecto a los niveles actuales. En concreto, en un ordenador cuntico sera posible que un bit no tuviese valores de 0 o 1, sino que podra estar en ambos estados simultneamente y realizar clculos con un gran nivel de paralelismo. Si bien es una tecnologa que an est en sus inicios (actualmente no se ha pasado de la construccin de puertas lgicas simples en laboratorio), presenta un futuro muy prometedor. De hecho, actualmente ya se han publicado algoritmos para ordenadores cunticos que resuelven problemas tradicionalmente considerados inabarcables, como la factorizacin de nmeros primos, que supondrn una autntica revolucin en campos como la criptografa cuando existan ordenadores cunticos en los que implementarlos.
16

Risc y Sics

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Risc y Sics

Hochgeladen von

Copyright:

Verfügbare Formate

Arquitectura de CPUs avanzadas.

Jess Jimnez Herranz, http://oposcaib.wikispaces.com

ADD R1,2 ST #46,R1 LD R1,#66 ADD R1,4 ST #70,R1

RAW RAW RAW

ADD R1,2 ST #46,R1 LD R1,#66 ADD R1,4 ST #70,R1

Jess Jimnez Herranz, http://oposcaib.wikispaces.com

Pos Opcode 1 2 3 4 5 ADD ST LD ADD ST

Mem Reg #46 #66 #70 R1 ... ER 4 ...

Listo Valor Ref ER Listo Valor Ref ER

Jess Jimnez Herranz, http://oposcaib.wikispaces.com

Histricamente, se han desarrollado diferentes tipos de procesadores vectoriales:

Procesadores con registros vectoriales

Jess Jimnez Herranz, http://oposcaib.wikispaces.com

Jess Jimnez Herranz, http://oposcaib.wikispaces.com

D12 D13 D14 D15

Jess Jimnez Herranz, http://oposcaib.wikispaces.com

Los objetivos de RISC son:

Jess Jimnez Herranz, http://oposcaib.wikispaces.com

Bloque de datos (2N posiciones)

Jess Jimnez Herranz, http://oposcaib.wikispaces.com

Asociativas por conjuntos

Jess Jimnez Herranz, http://oposcaib.wikispaces.com

Si, por ejemplo, suponemos la siguiente jerarqua de cach:

Jess Jimnez Herranz, http://oposcaib.wikispaces.com

Das könnte Ihnen auch gefallen