IS
2015
UNIVERSIDAD NACIONAL DE INGENIERIA
FACULTAD DE ELECTROTECNIA Y COMPUTACION
DEPARTAMENTO DE ARQUITECTURA Y SISTEMAS
ARQUITECTURA DE MAQUINAS COMPUTADORAS III
Paralelismo y Arquitecturas
Avanzadas
José L. Díaz Chow
Abril de 2015
José Leónidas Díaz Chow
Díaz - Medrano
IS 2013
Paralelismo y Arquitecturas Avanzadas
Folleto de apoyo para el estudiante
Elaborado por
Ing. José Díaz Chow ©
Edición original: Junio 2000
Última Revisión: Abril 2015
Universidad Nacional de Ingeniería, UNI.
Managua, Nicaragua.
Arquitectura de Máquinas Computadoras III
Paralelismo y Arquitecturas Avanzadas
INDICE DE CONTENIDO
1
PARALELISMO Y MEJORA DEL RENDIMIENTO.....1
1.1
EVALUACION DEL DESEMPEÑO .......................................................................... 1
1.1.1
1.1.2
1.1.3
1.1.4
1.1.5
1.1.6
1.1.7
1.1.8
1.1.9
1.2
REDUCCIÓN DEL TIEMPO DE EJECUCIÓN ....................................................... 12
1.2.1
1.2.2
1.2.3
1.2.4
1.3
2
DMA .................................................................................................................... 18
Procesadores y Canales de E/S ............................................................................ 18
INTRODUCCIÓN AL PARALELISMO................................................................... 18
1.5.1
1.5.2
1.6
Jerarquía de memoria ........................................................................................... 15
Principio de localidad de referencia. .................................................................... 16
Cálculo de la aceleración del rendimiento en la jerarquía de memoria ............... 16
MEJORAS AL SISTEMA DE ENTRADA-SALIDA ............................................... 17
1.4.1
1.4.2
1.5
Reducción del período de reloj. ........................................................................... 12
Reducción de la cantidad de instrucciones N....................................................... 12
Reducción del CPI................................................................................................ 13
Consecuencias de la ley de Amdahl..................................................................... 13
MEJORAS AL SISTEMA DE MEMORIA ............................................................... 15
1.3.1
1.3.2
1.3.3
1.4
Medida de rendimiento .......................................................................................... 2
Métricas de desempeño .......................................................................................... 2
Consideraciones de efectividad-costo .................................................................... 3
Técnicas de análisis de desempeño ........................................................................ 4
Rendimiento: .......................................................................................................... 4
Factores que determinan el tiempo de ejecución ................................................... 6
Ley de Amdahl....................................................................................................... 6
Cálculo del tiempo de Ejecución............................................................................ 8
Métricas populares de rendimiento ........................................................................ 9
Procesamiento paralelo ........................................................................................ 19
Diferentes mecanismos y técnicas de mejora del desempeño empleadas............ 19
CLASIFICACIÓN DE LAS ARQUITECTURAS PARALELAS............................. 21
SEGMENTACION......................................................... 23
2.1
INTRODUCCION ...................................................................................................... 23
2.2
RENDIMIENTO DEL PROCESADOR SEGMENTADO........................................ 26
2.3
CLASIFICACION DE LOS PROCESADORES ENCAUZADOS........................... 27
2.4
EL PROCESADOR SEGMENTADO DLX .............................................................. 28
2.5
DIFICULTADES DE LA SEGMENTACION........................................................... 30
2.6
DEPENDENCIAS ESTRUCTURALES.................................................................... 31
Arquitectura de Máquinas Computadoras III
Paralelismo y Arquitecturas Avanzadas
2.6.1 TABLA DE RESERVA DEL DLX.................................................................... 31
2.6.2 RIESGOS ESTRUCTURALES EN EL DLX ..................................................... 32
2.6.3 TABLA DE RESERVA CON DEPENDENCIAS ESTRUCTURALES
RESUELTAS .................................................................................................................... 34
2.6.4 DATAPATH DEL DLX ...................................................................................... 35
2.7
DEPENDENCIAS DE DATOS.................................................................................. 36
2.7.1
2.7.2
2.7.3
2.7.4
2.8
TIPOS DE DEPENDENCIAS DE DATOS ........................................................ 36
TRATANDO LAS DEPENDENCIAS DE DATOS EN EL DLX...................... 37
RESUMEN DE DEPENDENCIAS DE DATOS EN EL DLX ........................... 40
DATAPATH DEL DLX CON DEPENDENCIAS DE DATOS RESUELTAS . 42
DEPENDENCIAS DE CONTROL............................................................................ 43
2.8.1 ADELANTANDO LA DEFINICION DEL SALTO ........................................ 43
2.8.2 DEPENDENCIAS DE DATOS EN BRx TRAS ADELANTAMIENTO A D/L 45
2.8.3 TRATAMIENTO DE LAS LATENCIAS DE CONTROL ............................... 46
2.8.4 DATAPATH DEL DLX CON LAS DEPENDENCIAS DE CONTROL
RESUELTAS .................................................................................................................... 49
2.9
EXCEPCIONES ......................................................................................................... 50
2.9.1
2.9.2
INTRODUCCION ............................................................................................... 50
EXCEPCIONES EN EL DLX ............................................................................. 50
2.10 SEGMENTACION NO LINEAL............................................................................... 52
2.11 PROCESADORES MULTICICLO............................................................................ 53
2.12 PLANIFICACION DE RECURSOS.......................................................................... 54
3
ARQUITECTURAS SIMD ............................................ 56
3.1
INTRODUCCIÓN ...................................................................................................... 56
3.1.1
3.1.2
3.2
Tipos de Arquitecturas SIMD..................................................................................... 58
3.2.1
3.2.2
3.3
Procesadores vectoriales o Vector Processors ..................................................... 58
Procesadores matriciales o Array Processors....................................................... 59
Procesadores vectoriales Encauzados (Vector Processors) ........................................ 59
3.3.1
3.3.2
3.3.3
3.4
Necesidad de procesamiento de Vectores y matrices: ......................................... 56
Características y exigencias del procesamiento de Vectores / Matrices .............. 57
Cauces vectoriales................................................................................................ 59
Maquinas M-M, Memorias entrelazadas y Procesamiento en flujo continuo...... 59
Máquinas R-R y Encadenamiento de vectores.................................................... 60
Procesadores SIMD (Processor Arrays) ..................................................................... 61
3.4.1
3.4.2
3.4.3
Procesadores de arreglos de EPs. ......................................................................... 61
Enmascaramiento, limitando la estructura. .......................................................... 62
Importancia de VLSI en las Arquitecturas SIMD................................................ 62
Arquitectura de Máquinas Computadoras III
3.5
Procesadores Sistólicos............................................................................................... 62
3.5.1
3.5.2
3.6
Procesadores Asociativos..................................................................................... 64
Ejemplares............................................................................................................ 64
Estructuras y algoritmos para Procesadores Matriciales. ........................................... 65
3.8.1
3.8.2
4
Redes sincrónicas vs. redes asíncronas ................................................................ 64
WaveFront Array Processor................................................................................. 64
Procesadores Asociativos ........................................................................................... 64
3.7.1
3.7.2
3.8
Deficiencias de la taxonomía de Flynn. ............................................................... 62
Arreglos sistólicos................................................................................................ 63
Procesadores de Frente de Onda................................................................................. 64
3.6.1
3.6.2
3.7
Paralelismo y Arquitecturas Avanzadas
Estructuras de Interconexión – Comunicación EPs. ............................................ 65
Características de los Algoritmos matriciales. ..................................................... 65
ARQUITECTURAS MIMD. .......................................... 66
4.1. Introducción a los MIMD: Multiprocesadores .............................................................. 66
4.1
Clasificación de los sistemas MIMD. ......................................................................... 67
4.2
Estructuras de Interconexión. ..................................................................................... 67
4.2.1
4.2.2
4.2.3
4.2.4
4.2.5
4.3
Bus común............................................................................................................ 68
Conmutador Barra-Cruz....................................................................................... 69
Memorias Multipuerto ......................................................................................... 69
Redes Interconexión multietapa. .......................................................................... 70
Hipercubo............................................................................................................. 70
Acceso a recursos compartidos................................................................................... 71
4.3.1
4.3.2
Arbitraje del bus................................................................................................... 71
Exclusión mutua................................................................................................... 71
4.4
Comunicación entre Procesadores .............................................................................. 72
4.5
Coherencia de cachés.................................................................................................. 72
4.6
Sistemas Operativos y lenguajes de programación MP.............................................. 73
4.6.1
4.6.2
Sistemas operativos:............................................................................................. 73
Lenguajes: ............................................................................................................ 73
Arquitectura de Máquinas Computadoras III
Paralelismo y Arquitecturas Avanzadas
1 PARALELISMO Y MEJORA DEL RENDIMIENTO
1.1
EVALUACION DEL DESEMPEÑO
El poder valorar el desempeño de un sistema de cómputo es necesario, en diferentes escenarios,
para poder tomar decisiones. Por ejemplo, podríamos querer determinar si un sistema existente
es apto o cubre las necesidades de poder de cómputo de una aplicación específica. O podríamos
querer determinar si se requiere actualizar o ampliar sus capacidades. A nivel de diseño o de
actualización de un sistema, es importante poder predecir el rendimiento que tendrá el resultado
final y así poder determinar si éste será adecuado para el objetivo previsto. De este análisis se
podrán tomar decisiones acerca de la vialidad del proyecto. Así mismo, es indispensable poder
comparar rendimientos de diferentes opciones al momento de seleccionar el mejor sistema de
cómputo. Asimismo la evaluación del desempeño nos permite analizar el rendimiento de un
sistema y tomar acciones para su perfeccionamiento.
Para poder evaluar el desempeño de un computador y así poder compararlo respecto a otro
necesitamos poder definir y medir su rendimiento. Pero, ¿Qué queremos decir con
rendimiento?, ¿En base a qué parámetros podemos expresar o medir el rendimiento?, ¿Cómo
podemos establecer un mecanismo que me permita comparar dos computadoras? En esta unidad
daremos respuesta a estas preguntas y definiremos un marco conceptual que nos permita en
términos generales evaluar el desempeño de los equipos de cómputo.
Para poder cuantificar el rendimiento, necesitamos determinar los atributos, características o
factores que influyen en el desempeño del equipo de cómputo e identificar cuál de estos son
determinantes en el desempeño. Estos factores, por tanto deben ser medibles, directa o
indirectamente. Es decir, deben representar magnitudes. Se denomina medida al valor de una
magnitud obtenido mediante un instrumento de medición confiable. Se denomina métrica al
método de medición (y comúnmente la escala) de una medida que se considera estándar para
definir el desempeño de un sistema. En muchos casos, pueden existir diferentes medidas de
interés que pueden usarse para determinar el rendimiento en diferentes escenarios. A manera
de ejemplo, veamos algunas medidas de rendimiento de ciertos aviones:
Tabla 1.1. Cuadro comparativos de características de algunos aviones.
Aeroplano
Capacidad
[Pasajeros]
Alcance
[Millas]
Velocidad
[M.p.h.]
Productividad
[Pasajeros X Mph]
Boeing 737 - 100
101
630
598
60,398
Boeing 747
470
4,150
610
286,700
BAC/Sub Concord
132
4,000
1,350
178,200
Douglas DC-8-50
146
8,720
544
79,424
Página 1
Arquitectura de Máquinas Computadoras III
Paralelismo y Arquitecturas Avanzadas
De esta tabla podemos concluir que el avión con más velocidad es el Concord, el de mayor
alcance es el Douglas DC-8 y que el Boeing 747 es el de mayor capacidad. Así por ejemplo,
para un pasajero adinerado que quiere transportarse de un lugar a otro distanciado 4,000 millas
del primero, el Concord es el más rápido. Pero si queremos movilizar 450 personas de una zona
a otra distante las mismas 4,000 millas, entonces, el más rápido es el Boeing 747.
De manera análoga, el desempeño de un computador puede tener diferentes medidas de elección
para diferentes usuarios. Para un usuario individual que está ejecutando un único programa, la
computadora con mayor rendimiento es aquella que complete la ejecución de su programa en
menor tiempo. Sin embargo, para el administrador de un centro de cómputos, que tiene
múltiples tareas que realizar a la vez, la de mayor rendimiento es la que le realice más tareas en
menor tiempo. Como elemento común, sin embargo, se evidencia que la medida del
rendimiento del computador es el tiempo. La computadora que ejecute los programas en menor
tiempo es la que tiene mejor rendimiento.
1.1.1
Medida de rendimiento
La medida del rendimiento de interés en la computadora es el tiempo. Sin embargo,
podemos identificar diferentes medidas de tiempo. Por ejemplo, el tiempo de ejecución de
programas por parte del CPU, puede descomponerse en tiempos de usuario (en que ejecuta los
programas de los usuarios) y el tiempo de sistema operativo. También podemos identificar otros
tiempos que están ligados con los otros componentes del sistema de cómputo: el tiempo
requerido para realizar intercambio de datos con la memoria o con diferentes dispositivos de
entrada-salida que tienen muy diversas velocidades.
Dadas las diferencias e inexactitudes que considerar todos los tiempos posibles, puede acarrear,
se toma como la medida de rendimiento más adecuada del computador al tiempo de ejecución
t de un programa por parte del CPU.
1.1.2
Métricas de desempeño
Para poder evaluar el desempeño de un sistema de cómputo y poder comparar dos
sistemas en función de su rendimiento, necesitamos establecer métricas que nos permitan
estandarizar las medidas que emplearemos para tales fines. Las métricas establecen un criterio
estandarizado para evaluar el desempeño de un sistema de cómputo de forma general, de
manera que mediante la medida de tal métrica podamos comparar dos sistemas disímiles.
Todas las métricas de desempeño están basadas en el comportamiento del sistema durante el
tiempo, dado que el tiempo es la medida básica de rendimiento. Existen tres clases de métricas
que pueden denominarse externas, pues pueden percibirse por un usuario o entidad externa al
sistema medido:



Latencia o tiempo de respuesta.
Productividad
Disponibilidad
Página 2
Arquitectura de Máquinas Computadoras III
Paralelismo y Arquitecturas Avanzadas
Existe una cuarta métrica de tipo interna o que se percibe desde dentro del sistema. Es la
métrica de utilización. Esta última es de vital importancia para entender el sistema y predecir
su desempeño en condiciones específicas.
La latencia es una medida del tiempo (t) que el sistema tarda en producir resultados. Esta
métrica puede representar diferentes conceptos en dependencia del contexto, por ejemplo, en la
evaluación del desempeño del CPU, tenemos los ciclos de reloj requeridos para completar un
programa, el ancho del pulso o período del reloj del CPU y el tiempo total de ejecución de un
programa; en cambio, en la evaluación del rendimiento de la memoria, tenemos por ejemplo, el
tiempo de acceso a una celda.
La productividad o throughput () como métrica de rendimiento, es la cantidad de trabajos o
tareas completadas por unidad de tiempo. A diferencia del tiempo de ejecución que mide
directamente el rendimiento del CPU, la productividad depende de diferentes factores externos
y circunstanciales (acceso a disco, algoritmo de scheduling, entre otros) y mide un rendimiento
más global del sistema.
La disponibilidad (d) mide cuánto tiempo un sistema se mantiene en operación normal del
tiempo total requerido.
La utilización () es el fragmento de tiempo que un componente del sistema (CPU, disco,
memoria, etc) está activo para su utilización o contribuye al trabajo. La utilización se tasa en el
rango entre 0 y 1 o como porcentaje. La productividad máxima de un sistema se alcanza cuando
el componente más ocupado logra una utilización de 1 ó 100%.
Aunque las métricas nos permiten contar con un criterio de comparación genérico, muchas
veces es difícil definir métricas que sean efectivas 100% o estén libres de errores en los
procedimientos o casos de aplicación.
1.1.3
Consideraciones de efectividad-costo
En la evaluación de computadoras, sobre todo con fines económicos o financieros, también
incluye consideraciones de costos. Normalmente interesa el costo de producción o adquisición,
la tasa de retorno de la inversión (ROI) y el costo total de pertenencia (TCO).
La historia muestra proyectos costosos, como Cray, donde se busca a ultranza lograr el mayor
poder de cálculo con el mejor rendimiento. En estos casos, el costo no se consideró como una
métrica de decisión para la implementación del proyecto. En el otro extremo tenemos a los
proyectos de soluciones SOHO genéricos, donde el menor precio posible es la meta. Aunque el
rendimiento sí cuenta, se puede renunciar a ciertos beneficios en función de obtener un equipo
de bajo costo para un mercado con baja exigencia.
Quizás el mayor trabajo para el arquitecto o diseñador consiste en alcanzar el mayor
rendimiento posible al menor costo.
Página 3
Arquitectura de Máquinas Computadoras III
Paralelismo y Arquitecturas Avanzadas
Aunque en este curso nos limitaremos a la evaluación del desempeño más que a la
determinación de costos y su contrastación con los beneficios, sí haremos énfasis, en donde sea
pertinente, en aquellas técnicas que permitan aminorar el costo de los sistemas sin sacrificar la
eficiencia.
1.1.4
Técnicas de análisis de desempeño
Las técnicas de análisis del desempeño de la ejecución de computadoras se pueden clasificar
en cuatro grandes bloques:




Medición del desempeño (benchmarking)
Modelado analítico
Modelado por simulación
Modelado híbrido
Las técnicas analíticas y de simulación, requieren la construcción de un modelo: una
representación abstracta del sistema real. Un modelo analítico de la ejecución es una estructura
matemática, mientras que un modelo por simulación requiere del soporte de un programa de
computadora especializado.
La mayor parte del arte en análisis de la ejecución queda en seleccionar a un buen modelo que
integre los aspectos más sobresalientes del sistema, eliminando toda la masa de detalles no
pertinentes que puedan ocultar lo esencial del mismo.
La tercera técnica, medida de la ejecución, no usa modelos, pero en cambio se sustenta en la
observación directa y en la recolección de valores del sistema de interés, o un sistema similar.
Esta técnica incluye la elección de métricas y sus medidas a emplear para caracterizar el sistema
y el uso de benchmarks o programas que sirvan como carga de trabajo e instrumento de
medición.
Ninguna técnica es mejor en todos los casos. Los modelos analíticos y de simulación
predominan en escenarios donde no contamos con el sistema vivo o un prototipo del mismo.
Cuando queremos determinar el desempeño de un sistema existente, la técnica de medición de
la ejecución es lo más indicado.
En nuestro curso emplearemos sobre todo, métodos analíticos muy simples y genéricos
partiendo desde la óptica del diseñador que pretende logra un mejor desempeño de un sistema
proyectado más que desde la óptica de evaluar un sistema existente.
1.1.5
Rendimiento:
Dado que la medida de rendimiento es el tiempo, y que a menor tiempo de ejecución
tenemos mayor rendimiento, es decir, el Rendimiento (R) de una computadora es inversamente
proporcional al tiempo de ejecución (t) de la misma, para una carga definida. Por tanto,
podemos definir rendimiento como:
Página 4
Arquitectura de Máquinas Computadoras III
Paralelismo y Arquitecturas Avanzadas
=
1
Con esta medida ya podemos comparar dos computadoras. Sean Rx el rendimiento de la primera
y Ry el de la segunda, para una misma carga, podemos decir que:
Rx > Ry  1 > 1  ty > tx
tx
ty
Y podemos cuantificar la relación entre ellas: qué tanto más rinde X sobre Y con la razón
siguiente:
Rx
= n
Ry
Donde n es cantidad de veces que X tiene mayor rendimiento que Y. En dependencia del
contexto, n se conoce como ganancia “G” (si X es un reemplazo de Y) o como aceleración
(A) o mejora de rendimiento (si X es una evolución de la misma arquitectura de Y).
Por ejemplo, si una máquina A ejecuta un programa en 10s y una máquina B en 15s. ¿Qué tanto
mayor es el rendimiento de la máquina A sobre el de la máquina B?
n = tb / ta = 15 s / 10 s = 1.5
–
El rendimiento de A es 1,5 veces el de B.
Esta razón es adecuada como base de comparación respecto a la unidad, sin embargo, a veces
queremos saber en cuánto supera una a la otra, es decir, el incremento neto de rendimiento:
n’ = n – 1
O mejor aún, en qué porcentaje la una supera a la otra:
n% = ( n – 1) * 100%
Así el incremento porcentual del rendimiento de X sobre Y, puede expresarse como:
Rx - Ry
n% =
* 100%
Ry
Página 5
Arquitectura de Máquinas Computadoras III
Paralelismo y Arquitecturas Avanzadas
De donde podemos deducir que A es 50% más rápida que B. Queda como tarea al lector
interesado demostrarlo.
Una vez definida una metodología para comparar rendimientos de dos computadoras mediante
su tiempo de ejecución, es importante definir qué métricas o características básicas intervienen
en la definición de esta medida.
1.1.6
Factores que determinan el tiempo de ejecución
Los factores que inciden en el tiempo de ejecución de un programa son: la frecuencia f
del procesador y la cantidad de ciclos c que transcurren desde que el programa inicia hasta que
concluye, puesto que si podemos determinar ambas podremos determinar el tiempo de
ejecución.
La frecuencia define el ancho del pulso o período de reloj. Cabe mencionar que este período se
define en tiempo de diseño para ser suficientemente ancho a fin de permitir que todas las
operaciones de control requeridas por cualquier paso de control puedan realizarse sin problemas
en ese intervalo de tiempo. Así:
f = 1/
y
t  t = c *
Donde la constante c representa el total de ciclos de reloj que se requirió para ejecutar el
programa.
Con estas nuevas relaciones, podríamos obtener información para comparar dos computadoras
en función de su frecuencia. Por ejemplo, suponga que la máquina A ejecuta un programa p en
10s y su CPU tiene una frecuencia de reloj de 100MHz. Usted está diseñando una máquina B y
quiere que ésta ejecute p en solamente 6 segundos aunque sabe que para ello requiere una mayor
frecuencia de reloj y como consecuencia, serán requeridos 20% más de ciclos para completar
p. ¿Qué frecuencia debe tener B para lograr el objetivo?
ta = ca / fa  ca = ta * fa
cb = 1.2 * ca = 1.2 * ta * fa
fb = cb / tb = (1.2 * ta * fa) / tb
fb = (1.2 * 10s * 100MHz) / 6s = 200 MHz
1.1.7
Ley de Amdahl
Hemos obtenido expresiones que nos permiten relacionar el rendimiento de dos
máquinas. Cuando el rendimiento de una es mayor que el de la otra como efecto de introducir
una mejora, decimos que tenemos una aceleración de rendimiento. Es importante recalcar,
Página 6
Arquitectura de Máquinas Computadoras III
Paralelismo y Arquitecturas Avanzadas
sin embargo, que la aceleración global del sistema estará limitada por la fracción de tiempo en
que dicha mejora es efectiva. Es decir, no podemos esperar que el sistema global acelere al
doble si la mejora, que incrementa el rendimiento al doble, solo es capaz de funcionar cierto
porcentaje de tiempo.
Por ejemplo, supongamos que aumentamos la frecuencia de un CPU al doble, podría esperarse
reducir el tiempo de ejecución global a la mitad. Sin embargo, si en cada ciclo de instrucción
se pierde mucho accediendo datos de la memoria, la mejora global alcanzada no será del doble,
sino menor.
La ley de Amdahl nos permite cuantificar la aceleración global neta de un sistema donde se ha
introducido una mejora que es efectiva solo una fracción de tiempo de trabajo del sistema, es
decir, nos permite cuantificar el rendimiento en función de la utilización:
“La aceleración de rendimiento global neta obtenida de incorporar una mejora a un sistema
equivale a la razón entre el rendimiento del sistema al ejecutar una tarea completa con la mejora,
empleando esta todo el tiempo posible, sobre el rendimiento del mismo al ejecutar la misma
tarea sin la mejora, por cuanto el efecto neto de la mejora está limitado por la fracción de tiempo
en que ésta se puede usar”
Ag = Rmejorado / Roriginal = toriginal / tcon mejora
Siendo tg el nuevo tiempo de ejecución global del sistema al incorporar la mejora, t el tiempo
de ejecución original sin mejora, n la ganancia o aceleración parcial que la mejora proporciona,
y , la fracción mejorada (utilización) o el porcentaje de tiempo real que la mejora es efectiva,
entonces:
tg = ttramo en que la mejora es efectiva + ttramo sin mejora
tg 


*   t * (1   )  t * (1   )  
n
n

t
y:
Ag 
t
tmejorado

1
(1   ) 

n
Así por ejemplo, si una máquina se mejora duplicando la frecuencia del CPU, pero la mejora
solo es efectiva durante el 60% del ciclo de instrucción por el acceso a memoria, la aceleración
global del sistema sería:
Ag = 1 / 0.4 + (0.6/2) = 1/ 0.7 = 1.43
Página 7
Arquitectura de Máquinas Computadoras III
Paralelismo y Arquitecturas Avanzadas
Nota = 0.6 y n = 2
La ley de Amdahl nos conduce a un importante principio de diseño: Acelerar el caso común.
1.1.8
Cálculo del tiempo de Ejecución
Hemos determinado que el tiempo de ejecución depende netamente del total de ciclos
requeridos para ejecutar el programa por el período o duración del ciclo. Ahora analizaremos
más a fondo cómo obtener el total de ciclos del programa. Sabemos que en definitiva, un
programa es una serie de instrucciones a ejecutar. Cada una de estas instrucciones consume una
cantidad de ciclos para completarse, por tanto, la cantidad total de ciclos que emplea una
máquina para ejecutar un programa depende de la cantidad total de instrucciones que se
ejecutan:
N
t   *  Ci
i 1
Donde ci es la cantidad de ciclos de la i-ésima instrucción, y N es el total de instrucciones
ejecutadas en el programa. Si analizamos bien el programa, determinamos que existen grupos
de instrucciones que consumen la misma cantidad de ciclos de reloj, y por tanto, podemos
detallar el factor sumatoria de la expresión anterior como:
g
t  *cj *nj
j 1
Donde nj representa la cantidad de instrucciones del j-ésimo grupo y cj es la cantidad de ciclos
de reloj que requiere una instrucción del j-ésimo grupo para ejecutarse.
Sabemos del diseño del conjunto de instrucciones que en algunas arquitecturas, todas las
instrucciones tienen la misma cantidad de ciclos de reloj. En este caso, la ecuación anterior
tendría un solo grupo donde el factor “c1” se convierte en una constante a la que llamaremos
CPI (siglas de Ciclos Por Instrucción) y el factor “n1” en el total de instrucciones N.
En algunas arquitecturas, incluso es permisible hacer:
I
CPI 
c
i 1
i
I
Página 8
Arquitectura de Máquinas Computadoras III
Paralelismo y Arquitecturas Avanzadas
Siendo ci la cantidad de ciclos de la instrucción i-ésima del conjunto de instrucciones I de la
arquitectura en cuestión. Es decir, se utiliza como CPI el promedio de ciclos de las
instrucciones.
Al contar con un CPI constante, entonces el tiempo de ejecución “t” se puede definir como:
t   * CPI * N 
CPI * N
f
Donde CPI es la cantidad de ciclos por instrucción, N es el total de instrucciones ejecutadas,
 es el período de reloj y f es la frecuencia.
1.1.9
Métricas populares de rendimiento
Se han propuesto una serie de medidas de rendimiento populares en el intento de crear
una métrica estándar de rendimiento que nos permita comparar dos computadores cualesquiera.
Este es un esfuerzo enorme porque la meta es ambiciosa y difícil de alcanzar. Y aunque, como
resultado de los mismos se han propuesto una serie de métricas simples que se han empleado
ampliamente, éstas tienen un contexto de aplicación limitado y son susceptibles a errores de
utilización.
1.1.9.1
MIPS
Una métrica muy difundida es la “velocidad o frecuencia de ejecución de instrucciones” que es
una métrica del tipo productividad que normalmente se expresa en millones de instrucciones
por segundo o MIPS. En términos del tiempo de ejecución la velocidad de ejecución de
instrucciones equivale a la cantidad total de instrucciones ejecutadas sobre el tiempo total de
ejecución. Se emplea el múltiplo millones (dividiendo entre 10 a la 6) para obtener el resultado
en un número más legible.
MIPS 
N
f

6
t *10
CPI *10 6
Como MIPS es una frecuencia, expresa el rendimiento en proporción inversa al tiempo lo cual
es adecuado porque mayores MIPS indican máquinas más rápidas.
El problema con el uso de MIPS consiste en que si se emplea como método comparativo, debe
tenerse cuidado que las máquinas tengan características similares. Por ejemplo, un programa
que emplea emulación de las operaciones de punto flotante puede resultar con más MIPS que
una máquina que emplea una FPU aunque el tiempo de ejecución del programa sea menor en
la segunda, con lo cual el criterio MIPS nos conduce a un resultado equivocado. De manera
Página 9
Arquitectura de Máquinas Computadoras III
Paralelismo y Arquitecturas Avanzadas
similar, si el repertorio de instrucciones de ambas máquinas difiere, es posible que el resultado
también sea equivocado.
1.1.9.2
MIPS relativos
Para atacar el problema de dos máquinas con repertorios muy diferentes, se propuso emplear la
métrica MIPS relativos que se refiere a los MIPS de esta máquina en comparación con una
máquina de referencia. Se medía el tiempo de ejecución de un programa de prueba en la
máquina a evaluar y se dividía entre el tiempo de ejecución del mismo programa en la máquina
de referencia y finalmente se multiplicaba por los MIPS de la máquina de referencia, lo que nos
permitiría comparar dos máquinas respecto a una tercera.
MIPSRe lativos 
treferencia
tevaluando
* MIPSreferencia
Nuevamente los problemas de esta métrica son que evalúa el desempeño sólo para ese programa
específico, puesto que se han demostrado resultados equívocos con otro tipo de programas.
Adicionalmente, la dificultad de obtener una máquina de referencia adecuada con la misma
carga de los sistemas operativos y compiladores hace casi impráctico este método hoy día.
1.1.9.3
MFLOPS
Para atacar las deficiencias de MIPS, respecto a las diferencias en las operaciones de punto
flotante, que son extensivamente usados en los ámbitos de computación científica, se propuso
emplear los MFLOPS o Millones de Operaciones en Punto Flotante por segundo. Los
megaflops se obtienen del cociente entre el total de operaciones en punto flotante de un
programa sobre el tiempo de ejecución por 10 a la 6:
MFLOPS 
O punto _ flo tan te
t *106
Aunque está restringido a las operaciones en punto flotante, los MFLOPS son más consistentes
que los MIPS por cuanto la cantidad de operaciones no cambia de máquina a máquina. La
problemática que se presenta, sin embargo, es que los conjuntos de operaciones en punto
flotante disponibles de máquina a máquina no son estándares y por tanto algunas operaciones
se deben implementar en función de otras. Adicionalmente existen operaciones en punto
flotante que son muy rápidas y otras muy lentas.
1.1.9.4
MFLOPS Normalizados
Para la solución a los problemas de MFLOPS se ha propuesto el uso de los MFLOPS
Normalizados. Este método concede pesos relativos a cada tipo de operación en punto flotante
y permite además considerar las operaciones enteras. Al asignar pesos mayores a las
Página 10
Arquitectura de Máquinas Computadoras III
Paralelismo y Arquitecturas Avanzadas
operaciones complejas se puede “normalizar” la diferencia de velocidades permitiendo
comparar de manera más equitativa de dos máquinas.
MFLOPSnormalizados 
 O * peso _ relativo
i
i
t *106
El problema de MFLOPS normalizados, consiste en que evalúa el rendimiento para ese
programa tipo de prueba (benchmark) específico y que aunque representa una opción para
comparar dos computadoras, no representa el rendimiento de la máquina.
1.1.9.5
Elección de programas de prueba o benchmarks
Para poder determinar los valores o medidas para evaluar una computadora según tal o cual
métrica, se necesita establecer una carga de trabajo idónea. Esta carga de trabajo está compuesta
por uno o más programas tipo que permiten establecer una marca o benchmark de comparación
de esta computadora con otras. La elección de estos programas debe hacerse de forma cuidadosa
de acuerdo a la actividad para la que está pensada la computadora.
Existen cuatro tipos de Benchmarks de acuerdo a las tendencias que se han venido imponiendo:
1. Aplicaciones o Programas reales: Consiste en usar de carga de trabajo la aplicación
principal a emplear en el equipo específico o programas tipo predefinidos como:
Compiladores (GNU C), Procesadores de Texto (Tex) y Aplicaciones CAD (Spice).
2. Núcleos o Kernels: Emplea extracciones de secciones de código importante de
programas reales usadas para evaluar rendimiento, por ejemplo Livermore Loop y
LinPack.
3. BechMarks Reducidos o Toys: Emplean rutinas pequeñas (10–100 líneas) con
resultados conocidos. Se introducen y ejecutan fácilmente en computadores para medir
su desempeño. Ejemplo: QuickSort, Puzzle.
4. BechMarks Sintéticos: Análogos a la filosofía de los Núcleos. Se crean mezclas de
diferentes rutinas de programas reales o inventados por el diseñador del benchmark.
Determinan frecuencia media de operaciones y acceso a operandos en diferentes
escenarios de cómputo. No calculan algo que un usuario pueda utilizar solo pretende
determinar un perfil medio de ejecución que sirva de referencia para comparar con otras
máquinas. Ejemplos de éstos son: WhetStone y Dhrystone.
Página 11
Arquitectura de Máquinas Computadoras III
1.2
Paralelismo y Arquitecturas Avanzadas
REDUCCIÓN DEL TIEMPO DE EJECUCIÓN
Hemos determinado de qué factores depende el tiempo de ejecución, de manera que si
queremos reducirlo, habrá que reducir aquellos factores que inciden en proporción directa en el
tiempo de ejecución o incrementar los que lo hacen en proporción inversa. Como es de
esperarse, la interrelación entre los mismos o las limitaciones físicas o tecnológicas frenarán la
máxima aceleración o mejora que pueda alcanzarse.
1.2.1
Reducción del período de reloj.
La primera apuesta y la más obvia apunta a reducir el período de reloj . Para lograr este
cometido, sin embargo, puede ser necesario reimplementar la máquina completa por cuanto el
período de reloj se decide en función de la máxima cantidad de pasos de control que se requieren
ejecutar de una sola vez, así como la máxima duración de éstos. Las mejoras realizadas en este
sentido, han implicado reducciones en el grosor de la oblea de silicio con que se fabrican los
procesadores. A menor grosor, menor distancias a recorrer y por tanto menor tiempo de
propagación.
Como ejemplo, la familia Intel x86 ha ido reduciendo significativamente el período de reloj
(aumentando la frecuencia) del CPU:
Tabla 1.2. Frecuencias de CPUs ix86
CPU
Hasta
Desde
Hasta
8088, 8086
1.7
1.7
588.2
588.2
80186
1.7
4
588.2
250.0
80286
4
12
250.0
83.3
80386
25
33
40.0
30.3
80486
33
100
30.3
10.0
Pentium
1.2.2
(ns)
f (MHz)
Desde
66
233
15.2
4.3
Pentium II
266
400
3.8
2.5
Pentium III
450
1,300
2.2
0.8
Pentium 4
1,300
4,000
0.8
0.3
Reducción de la cantidad de instrucciones N.
La segunda línea de acción para reducir el tiempo de ejecución, consiste en reducir la
cantidad de instrucciones de los programas. Durante los 50´s y 60´s, de hecho, prevalecieron
los esfuerzos en este sentido. Los conjuntos de instrucciones se diseñaban cada vez más
complejos de forma que el programador tuviera a disposición diferentes formas de lograr la
misma operación.
Una meta común en estos esfuerzos fue el lograr la mayor ortogonalidad posible a fin que los
programas pudieran ser más compactos al permitir cualquier combinación de operandos en las
instrucciones. Posteriormente se encontró que esta dirección no llevaba a mejoras sustanciales
por cuanto al complejizar las instrucciones fue requerido complejizar el hardware del CPU,
Página 12
Arquitectura de Máquinas Computadoras III
Paralelismo y Arquitecturas Avanzadas
sobre todo de la unidad de control. Como consecuencia, fue necesario un período de reloj más
ancho o mayor cantidad de ciclos para ejecutar las instrucciones.
El surgimiento de la microprogramación con la gran flexibilidad de diseño que ésta proporcionó
a los arquitectos, propiciaron la propagación de los conjuntos de instrucciones complejos,
alentada por la asumpción incorrecta que siempre el hardware es más rápido que el software.
Afortunadamente el avance de la tecnología permitió mitigar el impacto de la introducción de
estos conjuntos de instrucciones complejos en el desempeño, al producirse hardware más
rápido.
Posteriormente, el proyecto RISC, determinó que ni los programadores ni los compiladores
estaban sacando todo el provecho a las instrucciones complejas. Adicionalmente, se pudo
comprobar que en muchos casos una sola instrucción compleja dilataba más tiempo en
ejecutarse que varias instrucciones más simples que realizaban la misma operación. Los
hallazgos de RISC proponen que en muchos casos es más eficiente un programa con mayor
cantidad de instrucciones si el hardware del CPU que lo ejecuta puede simplificarse y acelerarse
lo suficiente. Cabe mencionar que al momento que se introdujo RISC, se podía contar con
muchos registros de propósito general en el CPU a bajo costo, lo cual no era posible antes y por
tanto la mayoría sino que todos los operandos residían en memoria principal, imponiendo un
cuello de botella en la ejecución.
1.2.3
Reducción del CPI
Finalmente, también tenemos una importante posibilidad de mejorar el rendimiento al
reducir el CPI por cuanto este es un factor entero que n-plica el tiempo de ejecución. Imagine,
reducir el CPI de 4 a 2, reduciría categóricamente el tiempo de ejecución a la mitad.
La idea común en este sentido apunta a reducir el CPI a su mínima expresión, es decir, a 1.
Obviamente tal propósito requerirá un período de reloj muy ancho así como reducir al máximo
los cuellos de botella (acceso a memoria y entrada-salida).
Como actividad práctica, proponemos identificar qué tan eficiente es el procesador simple
basado en un bus común estudiado en los cursos anteriores. Identificar las limitantes de diseño
que inciden en su desempeño y proponer un diseño mejorado que permita reducir el tiempo de
ejecución.
1.2.4
Consecuencias de la ley de Amdahl
Hemos estudiado los factores de los cuales depende el rendimiento del CPU y cómo
reduciendo estos factores podríamos reducir el tiempo de ejecución. No podemos despreciar las
latencias del acceso a las otras partes de la computadora cuando queremos evaluar la aceleración
o impacto global que reducir el tiempo de ejecución tendrá en todo el sistema.
Puesto que cada instrucción a ejecutarse es llevada desde la memoria al CPU, las latencias en
el acceso a la memoria, limitarán la aceleración global del sistema, pues la aceleración lograda
Página 13
Arquitectura de Máquinas Computadoras III
Paralelismo y Arquitecturas Avanzadas
a lo interno del CPU no podrá usarse todo el tiempo sino solo una fracción de éste, según se
evidencia en el ejemplo del acápite 1.1.8. Un caso similar se dará con el acceso a dispositivos
periféricos cuando se requieran datos que deban leerse directamente de un puerto de entradasalida.
Por tanto, nuestro estudio de la mejora del rendimiento del ordenador no estaría completo sin
estudiar las mejoras del rendimiento de los otros dos subsistemas que componen la
computadora: la memoria y el sistema de entrada-salida.
Página 14
Arquitectura de Máquinas Computadoras III
1.3
Paralelismo y Arquitecturas Avanzadas
MEJORAS AL SISTEMA DE MEMORIA
Hemos aprendido que el efecto neto de las mejoras aisladas a una parte del sistema está
limitado por la fracción de tiempo que dicha mejora se pueda emplear. El sistema de memoria
es crítico en la ejecución de los programas por cuanto cada instrucción reside en memoria y
muchos de los operandos también.
De nuestro curso anterior conocemos que el ciclo de máquina de lectura o escritura en memoria
normalmente requiere varios ciclos de reloj, convirtiéndose en un verdadero cuello de botella
en el sistema de ejecución. En este sentido, el diseño del bus del sistema juega un rol muy
importante. En muchos casos, incrementar el ancho del bus puede incrementar
significativamente la velocidad de transferencia. Asimismo, implementar un diseño de
múltiples buses puede reducir cuellos de botella. También se pueden solapar en el tiempo
diferentes ciclos de acceso a memoria mejorando el desempeño global del sistema de memoria.
En este sentido, es evidente que una cualquier mejora de velocidad en el acceso a la memoria
es determinante en el rendimiento de la máquina. Existen dos métricas importantes en un
sistema de memoria: el tiempo de acceso y la capacidad. A lo largo de la historia de la
computación se ha mantenido una tendencia constante a demandar más y más memoria. Sin
embargo, en la medida que crece el tamaño de la memoria, se requieren más circuitos de
decodificación que retardan el acceso a las celdas de almacenamiento. Adicionalmente, la
tecnología de fabricación de la memoria también influye en el desempeño de la misma. La
memoria estática es muy rápida pero mucho más costosa que la dinámica. Los grandes tamaños
de memoria principal, relativamente barata, con que contamos hoy día solo son posibles gracias
a la memoria dinámica.
1.3.1
Jerarquía de memoria
Es evidente que para las tareas de cómputo actuales, incluso en computadores
personales, necesitamos grandes cantidades de memoria principal. Es igualmente evidente que
los costos hacen prohibitivo implementarlas en memoria estática, sino más bien en memoria
dinámica que es normalmente unas diez veces más lenta que la primera. Una solución razonable
consiste en introducir una memoria intermedia entre el procesador y la memoria principal que
no sea tan grande a fin que pueda ser rápida y además pueda implementarse con memoria
estática a un precio razonable.
Debido a su reducido tamaño y su mejora de velocidad de acceso sobre la memoria principal,
es importante que se garantice que en ella sólo se encuentren los datos e instrucciones más
usados. Este tipo de implementación de memoria intermedia se denomina caché.
Es importante destacar que este arreglo define cierta jerarquización del almacenamiento donde
en el más alto nivel tenemos el almacenamiento interno al CPU (registros) pasando por la caché,
continuando con la memoria principal hasta llegar al almacenamiento secundario. En cada
nivel se establecen diferentes valores de velocidad de acceso, capacidad, tecnología y costo
verificándose que a medida que bajamos en la jerarquía disminuye la velocidad de acceso (o
Página 15
Arquitectura de Máquinas Computadoras III
Paralelismo y Arquitecturas Avanzadas
aumenta el tiempo de retardo) y aumenta la capacidad. El modelo, para ser eficiente debe
imponer en lo posible que todo acceso se dé entre niveles adyacentes.
Finalmente, es posible introducir varios niveles intermedios si la brecha de velocidad entre los
diferentes niveles es significativa.
1.3.2
Principio de localidad de referencia.
Para que la jerarquía de memoria funcione, las cachés deben tener una utilización
cercana a 100%, pues de lo contrario la aceleración global lograda no justificaría el incremento
costo al introducir una memoria extra bastante cara. Afortunadamente, el principio de localidad
de referencia garantiza la consecución de este objetivo bastante bien.
Este principio se basa en los principios primitivos de la organización de la máquina Von
Neumann de secuencialidad de los programas y de vecindad de almacenamiento. Podemos
decir que el principio tiene dos componentes: uno temporal y el otro espacial. El temporal
predica que una palabra de memoria que se referencia en este momento, tiene gran probabilidad
de reverenciarse en el futuro cercano (debido a la modularidad y ciclos en los programas). De
forma similar, el componente espacial establece que las palabras vecinas de la palabra que se
está referenciando actualmente tienen alta probabilidad de referenciarse en el futuro próximo.
Figura 1.1. Jerarquía de Memoria.
1.3.3
Cálculo de la aceleración del rendimiento en la jerarquía de memoria
El cálculo del rendimiento de un sistema jerárquico de memoria con caché es un caso
específico de aplicación de la ley de Amdahl. La utilización de la caché se puede cuantificar
Página 16
Arquitectura de Máquinas Computadoras III
Paralelismo y Arquitecturas Avanzadas
mediante la tasa de aciertos (h) o el porcentaje de veces que una referencia a memoria se
encuentra efectivamente en la caché. La ganancia del sistema o aceleración del rendimiento
del tramo mejorado es la proporción en la cual la velocidad de acceso a la caché supera a la
memoria principal, por ejemplo: si la caché tiene un tiempo de acceso de 10ns y la memoria
principal tiene un tiempo de acceso de 100ns, la ganancia (n) del sistema cuando se puede
acceder a caché es de 10. Así el tiempo de acceso global de un sistema con caché en función
del los tiempos de accesos de sus memorias es:
t g  tc * h  t M * (1  h)
Siendo tg el tiempo global del sistema, tc el tiempo de acceso de la caché y tm el tiempo de
acceso de memoria principal
1.4
MEJORAS AL SISTEMA DE ENTRADA-SALIDA
De forma similar al sistema de memoria, en la Entrada/Salida, la brecha de ancho de
banda entre dispositivos de diferentes velocidades de trasferencias se puede reducir mediante
la jerarquización de buses y la anexión de buffers en algunos módulos controladores de
entrada-salida. Además de el equilibrio de ancho de banda, se pueden solapar en el tiempo las
operaciones de transferencia de datos con las operaciones de CPU, mediante la incorporación
de controladores de DMA, canales de E/S y módulos inteligentes de dispositivos.
CPU +
Cache L1
Controlador
de vídeo
Cache L2
Controladores del sistema
(Chipset)
Controlador de Memoria y
Puente PCI
"Bus" AGP
Memoria
Principal
Bus del Sistema
Bus PCI
SCSI
Dispositivos IDE
CD
DD
DD
DD
Controlador IDE
Controlador de DMA
Puente PCI a ISA
LAN
Slot
USB
Bus ISA
Slot
Slot
LPT
Disquete
Super
I/O
Com 1
Com 2
Teclado
Ratón PS/2
Figura 1.2. PC con jerarquización de buses de E/S.
Página 17
Arquitectura de Máquinas Computadoras III
1.4.1
Paralelismo y Arquitecturas Avanzadas
DMA
Este método de transferencia avanzado, se implementó con el objetivo de mejorar la
velocidad de transferencia de datos, sobre todo para dispositivos y aplicaciones de E/S muy
rápidos (Adquisición de sonido, discos duros de alta velocidad y video). Consiste en proveer
un procesador auxiliar capaz de hacer E/S por programa directamente a la memoria, relevando
al CPU de esta tarea.
DMA se aprovecha cuando los dispositivos son capaces de transferir gran cantidad de datos de
una vez. Surge un problema de concurrencia en el bus del sistema respecto al CPU. Este se
resuelve con Cycle Stealing, que permite al procesador de DMA bloquear al CPU el uso del
bus algunos ciclos a fin de realizar la transferencia de DMA.
Cuando un programa desea realizar una transferencia empleando DMA, el CPU inicializa los
parámetros de la misma e indica al Módulo DMA, acto seguido, el CPU se desentiende de la
transferencia. El procesador de DMA coordina el acceso al dispositivo y sincroniza la
transferencia en función del esquema de sincronización del bus del sistema. El procesador de
DMA y el dispositivo de E/S se sincronizan mediante líneas de control del Procesador de DMA
denominadas canal de DMA.
Una ventaja de DMA sobre interrupciones es que la transferencia en DMA puede hacerse en
cualquier ciclo, en tanto en Interrupciones, la verificación de solicitudes de interrupción se hace
hasta al final de la fase de ejecución.
1.4.2
Procesadores y Canales de E/S
Son una evolución de DMA. Consisten en procesadores inteligentes de tratamiento de
E/S, capaces de atender a múltiples dispositivos a la vez. A diferencia de DMA que empleaba
el bus del Sistema para realizar la transferencia, cuando se usa un IO Processor, IO Channel o
Canal de E/S, los dispositivos se conectan directamente al canal de E/S. Actualmente, los
módulos DMA emplean Procesadores de E/S y pueden ofrecer las mismas características que
ofrecen los canales.
Estos Procesadores de E/S se implementaron en computadoras grandes (Supercomputadoras,
mainframes y en algunas Minicomputadoras) permitiendo jerarquizar el sistema de E/S
reduciendo la brecha de velocidades entre los diferentes dispositivos.
1.5
INTRODUCCIÓN AL PARALELISMO
Debido a la interrelación de los factores que determinan el tiempo de ejecución y a las
limitaciones propias de la arquitectura secuencial, existe una máxima aceleración que se puede
lograr en el tiempo de ejecución. Cuando se requiere mayor desempeño, no queda otro camino
que mejorar la arquitectura introduciendo paralelismo. Por ejemplo, es posible que una persona
no puede ser más rápida en ejecutar una tarea por mucho que se esfuerce, sin embargo, quizás
dos personas sí puedan hacerlo si comparten el trabajo.
Página 18
Arquitectura de Máquinas Computadoras III
Paralelismo y Arquitecturas Avanzadas
En computación se ha evidenciado, desde sus inicios, una necesidad y tendencia hacia el
paralelismo:




1.5.1
Se requiere cada vez más poder de cómputo y además concurrencia (datos compartidos).
Desde la introducción de las primeras enormes y costosas máquinas se requirió
capacidad de atención a múltiples usuarios para que fueran costo-efectivas.
Los dominios de aplicación se han ido ampliando cada vez más: desde un procesamiento
de datos se ha pasado a un procesamiento de información, de conocimiento y
últimamente se habla de “inteligencia”.
Los avances continuos en tecnología de producción de hardware a gran escala facilitan
la producción de sistemas paralelos a menor costo.
Procesamiento paralelo
El procesamiento paralelo es una forma eficaz de procesamiento que favorece la
explotación de los sucesos concurrentes en un sistema de computación. Esta concurrencia
implica simultaneidad, solapamiento y multiplicidad de recursos. El paralelismo que involucra
solapamiento se denomina temporal porque permite la ejecución concurrente de sucesos sobre
los mismos recursos en intervalos intercalados de tiempo. El paralelismo que permite
simultaneidad real sobre múltiples recursos al mismo tiempo se denomina paralelismo espacial.
1.5.2
Diferentes mecanismos y técnicas de mejora del desempeño empleadas
A medida que se fueron evidenciando las necesidades y requerimientos de mayor poder
de cómputo y rendimiento en los sistemas se fueron implementando una serie de técnicas y
mecanismos de mejora del desempeño que introducen algún nivel de paralelismo que han ido
evolucionando y consolidándose permitiendo los niveles de rendimiento que tenemos en las
computadoras hoy día:
1.5.2.1
Multiprogramación y tiempo compartido.
Esta es una técnica de software introducida por los diseñadores de sistemas operativos para
implementar paralelismo temporal en la ejecución de múltiples procesos de usuarios y los
mismos procesos del sistema operativo, logrando que todos progresen a la vez. La
multiprogramación permite tener múltiples procesos en memoria y sólo realiza cambio de
contexto con los procesos de house keeping de sistema o cuando el proceso se bloquea en espera
de un servicio. El tiempo compartido es más dinámico en el sentido que asigna un quantum de
tiempo de CPU a cada proceso.
1.5.2.2
Solapamiento de las operaciones CPU y E/S.
Mecanismos de mejora del sistema de entrada/salida que permite liberar al CPU de las
operaciones de entrada–salida, permitiéndole ejecutar otras operaciones. Este mecanismo
requiere la introducción de procesadores auxiliares para la transferencia de entrada–salida a
Memoria: controlador DMA, Canales de E/S y controladores de E/S inteligentes.
Página 19
Arquitectura de Máquinas Computadoras III
1.5.2.3
Paralelismo y Arquitecturas Avanzadas
Jerarquización y equilibrio de ancho de banda.
Las diferencias de velocidad entre diferentes componentes del sistema afectan el desempeño
global del mismo por los cuellos de botella que los dispositivos más lentos imponen en las
transferencias entre ellos. La jerarquización de diferentes niveles y la introducción de niveles
intermedios que reduzcan la brecha de velocidad, permite ir equilibrando el ancho de banda del
sistema y acelerar su rendimiento global. En el sistema de memoria contamos con la jerarquía
de memoria y en los sistemas de entrada salida con técnicas de compensación con la
jerarquización de buses y técnicas de buffering en los módulos de entrada/salida.
1.5.2.4
Solapamiento de la ejecución y Segmentación encauzada.
El modelo de ejecución de las máquinas secuenciales puede ser ineficiente en cuanto al nivel
de utilización de los componentes internos del CPU, al ocupar todos los recursos en el ciclo
de instrucciones completo. Un análisis de las fases y etapas del ciclo nos permiten identificar
diferentes tareas que podrían solaparse. Por ejemplo, la fase fetch solo se encarga de traer la
próxima instrucción. Finalizada la fetch, el PC no vuelve a utilizarse hasta la próxima fase
fetch. Entonces, podría considerarse que cuando se complete la traída de la instrucción i, una
parte dedicada del CPU puede ir a traer la siguiente instrucción i+1, mientras el resto ejecuta
la instrucción i. Cada parte o sección del CPU se denomina en este caso etapa o segmento del
cauce de ejecución o pipeline, porque la salida de cada etapa anterior alimenta la entrada de la
siguiente como si estuvieran conectados en una tubería. Por eso la implementación de tal
solapamiento de la ejecución en el CPU se denomina segmentación encauzada. El ejemplo de
segmentación mostrado en este párrafo solo consta de dos etapas y se le conoce como
precarga de instrucciones (prefetching), sin embargo los sistemas segmentados hoy día suelen
tener muchas más etapas de cauce.
La técnica de solapamiento de la ejecución, permite reducir considerablemente el tiempo de
ejecución, como lo estudiaremos en la unidad 2.
Adicionalmente, los sistemas de acceso a memoria también han implementado un modelo de
solapamiento en los ciclos de máquina de acceso a memoria, permitiendo reducir
grandemente el tiempo de respuesta global del sistema.
Página 20
Arquitectura de Máquinas Computadoras III
Paralelismo y Arquitecturas Avanzadas
Suma
Multiplic. 1
Banco de
Registros
(24 x 32)
Multiplic. 2
División
Suma Fija
Incremento
Subsistema de Entrada
/ Salida
Memoria Central
Decremento
Lógica
Desplazamiento
Bifurcación
Pila de
Instrucciones
Marcador
Figura 1.3. Multiplicidad de unidades funcionales en le CDC-6600
1.5.2.5
Sistemas escalares o multiplicidad de unidad funcionales
La introducción de la segmentación de bajo nivel o prefetching de instrucciones,
condujo a otra mejora en rendimiento que consiste en agregar más de una unidad aritmética
al procesador a fin de poder acelerar aún más la ejecución. Con esta importante mejora de
diseño, podrían tenerse más de una instrucción en ejecución a la vez. Este modelo, sin
embargo introduce requerimientos nuevos también en cuanto a mantener el orden estricto de
ejecución de las instrucciones y el control de disponibilidad de los recursos. A los sistemas
que implementan esta mejora se les conoce como sistema escalares. Por ejemplo, la CDC6600 que se muestra en la figura 1.3, emplea una cola de instrucciones y 10 unidades
aritméticas además de un marcador o scoreboard para registrar y controlar la disponibilidad
de las unidades funcionales y los registros.
1.5.2.6
Sistemas paralelos.
Las técnicas mencionadas arriba, explotan mayormente el paralelismo temporal.
Algunas introducen elementos de paralelismo espacial al incorporar elementos auxiliares de
proceso o varias unidades funcionales. Aunque los sistemas escalares introducen un nivel
interesante de paralelismo espacial, suele denominarse “sistemas paralelos” solamente a
aquellos que explotan el paralelismo efectivamente mediante la multiplicidad de procesadores
o elementos de procesamiento simples o complejos que colaboran en la solución de uno o más
problemas de forma simultánea.
Existen varios tipos y arquitecturas que estudiaremos a lo largo de la unidad 3 y 4.
1.6
CLASIFICACIÓN DE LAS ARQUITECTURAS PARALELAS.
Página 21
Arquitectura de Máquinas Computadoras III
Paralelismo y Arquitecturas Avanzadas
Se han propuesto diferentes criterios para clasificar las arquitecturas paralelas, según diferentes
características y niveles de paralelismo. De entre estas resaltan las de Flynn, Feng, Handler,
Hockney - Jesshope y Shore.
1.6.1.1
Taxonomía de Flynn
Flynn propone establecer categorías de clasificación en función de la multiplicidad de los
flujos de datos y de instrucciones que se conjugan en la ejecución de estos sistemas.
Considerando que un flujo puede ser simple o múltiple, establece cuatro categorías posibles:

SISD (Simple flujo de inst.-simple flujo de datos)
Esta categoría incluye a todos los sistemas de un solo CPU. Las ejecuciones se
ejecutan de forma secuencial pero puede haber segmentación.
Ejemplos de esta categoría son los computadores viejos IBM 370 e IBM 7090, el
VAX y el Intel 8086.

SIMD (Simple flujo inst.-multiples flujos de datos)
Esta categoría incluye una gran diversidad de procesadores paralelos que ejecutan una
misma instrucción sobre un conjunto de datos al unísono o solapadamente. Las
máquinas típicas SIMD son los procesadores matriciales con una red de múltiples
elementos de proceso (EP) supervisados todos por una la misma unidad de control.
Todos los EP reciben la misma instrucción emitida por la unidad de control y operan
esta instrucción sobre los datos residentes en su memoria local. Los miembros de esta
categoría serán nuestro objeto de estudio de la unidad 3.

MISD ( Múltiples flujos inst.-simple flujo de datos)
Este modelo propone la existencia de n unidades procesadoras; cada una recibe
distintas instrucciones que operan sobre el mismo flujo de datos. La salida de un
procesador pasa a ser la entrada del siguiente. Muchos autores coinciden en que no
existe espécimen para esta categoría aunque algunos insisten en considerar las etapas
de un cauce como entidades procesadoras y ubican los sistemas segmentados en esta
categoría.
Dado que las etapas no son autónomas, nuestra posición para efectos de este curso será
aceptar y declarar la vacuidad de esta categoría.

MIMD (Múltiples flujos inst.-multiples flujos de datos)
Esta categoría incluye a todos los sistemas paralelos que constan de múltiples
procesadores autónomos trabajando cooperativa y coordinadamente en la solución de
uno o más problemas de forma simultánea. Esta categoría nos ocupará durante la
unidad 4.
Página 22
Arquitectura de Máquinas Computadoras III
Paralelismo y Arquitecturas Avanzadas
2 SEGMENTACION
2.1
INTRODUCCION
La ejecución secuencial de instrucciones es muy lenta. Hemos expuesto que las mejoras
en tiempo de ejecución están limitadas por la interrelación entre las variables de la definición
del tiempo de ejecución secuencial t, que depende del número de instrucciones ejecutadas N, el
número promedio de ciclos de reloj consumidos por cada instrucción CPI y el período de reloj
del CPU, según muestra la expresión:
t = N * CPI
¿Existe alguna posibilidad de ejecución para aumentar el rendimiento reduciendo el tiempo de
ejecución? Pues sí: aplicar técnicas de paralelismo. Una de las técnicas de paralelismo más
empleadas por ser implementadas a lo interno del procesador es la segmentación encauzada o
pipelining en lengua inglesa. Se ha anotado que existen dos tipos de segmentación: la lineal y
la no-lineal. La ejecución segmentada de instrucciones es un ejemplo de segmentación lineal,
que será nuestro foco de interés en este capítulo.
La segmentación encauzada es una técnica de implementación que consiste en solapar la
ejecución de múltiples instrucciones en el tiempo. Eso significa que no se requiere esperar hasta
que la i-ésma instrucción concluya para comenzar a ejecutar la i+1-ésima instrucción. Hoy en
día, la segmentación es clave en la implementación de CPUs rápidos. Cabe mencionar que la
segmentación también se emplea en la construcción de unidades aritméticas. La figura 2.1.
muestra la ejecución secuencial que conocemos del curso anterior versus la ejecución solapada
que permite la segmentación.
Figura 2.1. Ejecución secuencial frente a la segmentada.
La segmentación es similar a una línea de producción en serie o cadena de ensamblaje: la cadena
se compone de una serie de fases o etapas consecutivas de producción que son necesarias para
Página 23
Arquitectura de Máquinas Computadoras III
Paralelismo y Arquitecturas Avanzadas
completar el producto o tarea. El producto se construye con diferentes piezas o partes que se
ensamblan en cada etapa de la cadena. Cada etapa cuenta con el equipamiento requerido para
completar la subtarea que le compete. En cada etapa de la cadena se ensambla una parte o pieza
y al final de la misma tenemos el producto completo. La gran ventaja es que no se necesita
esperar a que un producto completo esté listo para comenzar a ensamblar el siguiente, sino que
apenas una etapa completa su parte del trabajo, la pasa a la siguiente y comienza a procesar su
parte correspondiente del siguiente trabajo.
Análogamente, en la segmentación encauzada, la ejecución de una instrucción se divide en
diferentes fases y el procesador se organiza en unidades o secciones de ejecución relativamente
independientes llamadas segmento o etapa. Cada etapa de la segmentación completa o ejecuta
una parte de la instrucción. La CPU segmentada trabaja entonces como una línea de producción
en serie: La primera etapa carga la primera instrucción y completa su primera fase. Una vez que
esta fase ha terminado, pasa su salida a la siguiente etapa y toma la segunda instrucción mientras
la segunda etapa ejecuta la segunda fase de la primera instrucción. Este procedimiento se repite
entre las restantes etapas. Cuando la primera instrucción sale de la última etapa, su ejecución
está completa. En el siguiente pulso de reloj saldrá la segunda del cauce y así en lo sucesivo.
La figura 2.2. muestra el diagrama a bloques cómo se estructura un cauce de instrucciones que
opera según lo descrito. Cada etapa, en el gráfico se representa con un bloque verde. Los
bloquecitos celestes representan latches o registros de retención que tienenla misión de separar
los datos entre etapas, para evitar sobreposición de los mismos, según se explicará
posteriormente.
Figura 2.2. Diagrama de bloques de un cauce de Instrucciones.
Como todas las etapas están conectadas entre sí, todas ellas deben estar listas para proceder al
mismo tiempo; es decir, deben estar sincronizadas. El tiempo requerido para desplazar una
instrucción, un paso a lo largo del pipeline normalmente se hace corresponder a un ciclo del
reloj del procesador (). La duración de un ciclo máquina, está determinada por el tiempo que
necesita la etapa mas lenta, porque todas las etapas deben progresar a la vez. El diseñador debe
entonces, equilibrar la duración de las etapas de la segmentación. Si las etapas están
perfectamente equilibradas, el ciclo de la máquina segmentada es óptimo porque reduce el
gasto por segmentación.
El objetivo de la segmentación es conseguir una instrucción por ciclo, aunque cada instrucción
por separado ocupe varios ciclos (CPI > 1). La productividad de la segmentación está
determinada por la frecuencia con que una instrucción salga del cauce. La segmentación
incrementa la productividad de instrucciones de la CPU porque el número de instrucciones
completadas por unidad de tiempo se incrementa aunque no reduce el tiempo de ejecución de
cada instrucción debido al gasto en el control de la segmentación. El incremento en la
Página 24
Arquitectura de Máquinas Computadoras III
Paralelismo y Arquitecturas Avanzadas
productividad de instrucciones significa que un programa corre mas rápido y tiene menor
tiempo total de ejecución aun cuando ninguna instrucción se ejecute con mas rapidez.
El cauce de instrucciones mostrado en la figura 2.2. es un cauce lineal porque todas las etapas
tiene una relación de precedencia lineal entre ellas. El cauce lineal obliga a todas las
instrucciones a atravesar todas y cada una de las etapas del mismo, aunque no la necesite y por
tanto todas las instrucciones duran igual tiempo.
La precedencia está definida como una relación en el conjunto de subtareas en las que se divide
la tarea global que ejecuta el encauzado y define el orden de ejecución de las mismas:
Sea una tarea T, definida como el conjunto de subtareas requeridas para completarse:
T = {T1, T2, ...., Tk}
Si se verifica que la subtarea Tj no inicia hasta completar Ti  i < j y que una subtarea solo se
ejecuta una vez, entonces las subtareas tienen entre sí una relación de precedencia lineal. Si las
subtareas pueden ejecutarse en diferentes orden y/o repetidamente, se tiene una relación no
lineal de precedencia y se dice que el cauce es no lineal o general.
Un cauce puede representarse en forma de diagrama de bloques como la figura 2.2 o como un
grafo de precedencia donde se muestre la relación entre las subtareas.
El funcionamiento de un cauce de instrucciones puede modelarse mediante diagramas de
instrucciones o diagramas espacio-tiempo. El primero muestra el solapamiento de las
instrucciones en el tiempo y el segundo la utilización del cauce.
Figura 2.3. Diagramas de Instrucciones y Espacio-Tiempo.
El diagrama Espacio-Tiempo, introducido por Chen, se conforma por un cuadrante
bidimensional con el Espacio (etapas del cauce) en el eje de las “y” y el tiempo (ciclos de reloj
consumidos) en el eje de las “x”. Cada tramo espacio-tiempo representa la ejecución de la
SubTarea Ti en la etapa j. El subíndice representa la etapa y el superíndice la tarea.
Página 25
Arquitectura de Máquinas Computadoras III
2.2
Paralelismo y Arquitecturas Avanzadas
RENDIMIENTO DEL PROCESADOR SEGMENTADO
Hemos establecido que el rendimiento de las computadoras puede determinarse a través de dos
medidas principales: el tiempo de ejecución y la productividad. En un procesador encauzado,
el rendimiento es superior al de un procesador secuencial debido al solapamiento (paralelismo
temporal) en la ejecución. Sabemos que el tiempo de ejecución en un procesador secuencial
es:
t1 = N * CPI * 
Donde el subíndice 1 de t denota que es secuencial, es decir, solo tiene 1 etapa que ejecuta toda
la instrucción de una vez. N son las instrucciones totales ejecutadas y es el período de reloj.
Procedamos ahora a determinar una expresión para el tiempo de ejecución de un procesador
segmentado de k etapas tk.
El período del reloj de un procesador encauzado depende de la duración de la etapa más lenta,
porque estamos modelando una cadena de producción donde todas las etapas deben proceder al
mismo tiempo. Así el período, para un procesador de k etapas es:
Figura 2.3. Cálculo del período de un procesador encauzado..
Como todas las instrucciones duran lo mismo, puesto que deben pasar por todas las etapas del
cauce, y suponiendo que éste requiere un solo ciclo de reloj para ejecutar las operaciones de
cada etapa, entonces el CPI de todas las instrucciones equivale al número de etapas del cauce,
es decir: CPI = k.
El procesador encauzado, requiere k ciclos de reloj para producir la primera instrucción. Una
vez que el cauce está lleno, se produce una instrucción por ciclo, como puede apreciarse en la
figura 2.1. Entonces, podemos definir el tiempo de ejecución como el tiempo requerido para
ejecutar la primera instrucción (k * ) más el tiempo requerido para el resto que no es más N-1
ciclos. Así el tiempo de ejecución segmentado, denotado por t k es:
tk = k *  + ( N – 1) * 
Así la ganancia de rendimiento de un procesador segmentado sobre uno secuencial se define
como:
Página 26
Arquitectura de Máquinas Computadoras III
Paralelismo y Arquitecturas Avanzadas
La máxima ganacia del cauce es el límite de G cuando N  ∞ que es k, por tanto G = k.
La productividad del cauce depende de la eficiencia del mismo, es decir, de la capacidad de
mantenerse lleno, pues es solo con cauce lleno que este logra su objetivo de producir una
instrucción por ciclo. La Eficiencia, es por tanto, una medida de la utilización del cauce. De
forma general, resulta de la razón de tramos espacio-tiempo ocupados sobre el total de tramos
transcurridos durante la evaluación (ver figura 2.3). Más adelante se estudiará que existen
riesgos de control que evitan la utilización total del cauce en todo momento, con lo cual este
cálculo varía.
Nótese que los tramos ocupados durante la primera instrucción se complementan con los tramos
desocupados una vez que la última instrucción entra al cauce, por tanto, el total de tramos llenos
es: N * k *  y el total de tramos es: k *  *[ k + (N -1)]. Así, la eficiencia es:
Es fácilmente deducible que 1 cuando n . Notar que  = G / k.
Así, la Productividad que se define como el número de tareas (instrucciones) producidas por
unidad de tiempo es:  = N / t. Sustituyendo la expresión del tiempo de ejecución del
segmentado, nos queda:
Nótese que la productividad, entonces depende de la eficiencia y que la Productividad máxima
 = f.
2.3
CLASIFICACION DE LOS PROCESADORES ENCAUZADOS.
Existen varios criterios de clasificación:
A) Por Niveles de procesamiento (Händler):
 Cauce de Instrucciones.
 Ejemplo del DLX
Página 27
Arquitectura de Máquinas Computadoras III
Paralelismo y Arquitecturas Avanzadas
 Cauce Aritmético.
 Ejemplo del sumador de PF
 Encauzamiento de Procesadores.
 No es práctico.
B) Dependiendo de las configuraciones y estrategias de control:
 Unifunción – Multifunción
 Estático – Dinámico
 Escalares – Vectoriales
2.4
EL PROCESADOR SEGMENTADO DLX
En este curso, presentaremos el procesador segmentado DLX como caso de estudio
idóneo para la segmentación lineal. El DLX es un modelo didáctico propuesto por Hennessy y
Patterson en [Hen90] para el estudio de arquitectura de computadoras desde un enfoque
cuantitativo. Su nombre deriva del promedio (expresado en números romanos) de los números
de modelo de diferentes arquitecturas actuales que inspiraron su diseño. Según los autores, debe
pronunciarse DéLuX.
El DLX es un procesador RISC de 32 bits, segmentado en 5 etapas. Es una máquina de cargaalmacenamiento, es decir que sólo estas dos instrucciones acceden a memoria y todas las de
cálculo se efectuan estre registros del procesador. La etapas del DLX son las siguientes:
BUS o IF
Etapa de búsqueda o fetch de la intrucción e incremento del pc
DL o ID
Decodificación/Carga de operandos (registros) en ALU.
ALU o EX
Ejecución de operaciones y cálculo de direcciones efectivas de
datos en memoria.
MEM
Accesso a memoria para lectura (M R) o para escritura
(RM).
ESC o WB
Escritura de resultados en los registros.
A continuación se presenta una pequeña comparación entre las Arquitecturas RISC/CISC con el objetivo
de facilitar al lector la comprensión del funcionamiento del DLX que se expondrá luego en este
documento.
Página 28
Arquitectura de Máquinas Computadoras III
Paralelismo y Arquitecturas Avanzadas
RISC
CISC
Pocos formatos de instrucciones y
sencillos permiten decodificador rápido
y control cableado.
Muchos formatos muy complejos que
normalmente requieren unidad de control
microprogramada.
Las operaciones de cálculo son registroregistro. Instrucciones específicas de
carga y almacenamiento.
Las operaciones permiten operandos en
memoria.
Usan la mínima cantidad de modos de
direccionamiento.
Buscan permitir la máxima cantidad de
modos de direccionamiento.
Programas largos pero sencillos.
Programas cortos pero complejos.
Más fácil de segmentar por su sencillez.
Más difícil de segmentar y controlar.
Mayor rapidez de ejecución.
Ejecución más lenta (complejidad + UC
Prog)
CONJUNTO DE INSTRUCCIONES DEL DLX
Aunque el repertorio provisto por Hennesy-Patterson es bastante extenso, nos
limitaremos a un conjunto mínimo de Macro-instrucciones que caracterizan suficientemente el
procesador para nuestro estudio:
Cálculo
OP R1, R2, R3
; R1 = R2 OP R3
Acceso a
Memoria
LOAD R1, d(R2)
; R1 = M( R2 + d )
STORE d(R2), R1
; M( R2 + d ) = R1
BRx R1, d
; If ( R1 cond 0) then PC = PC +
d
Saltos
Nota: x puede ser:
E
( cond es = )
LT ( cond es < )
GT ( cond es > )
NE ( cond es # )
LE ( cond es <= )
GE ( cond es >= )
Nótese que la instrucción OP es genérica acá por razones de simplicidad, sin embargo OP puede
ser cualquier operación binaria soportada por DLX, por ejemplo: ADD, SUB, AND, OR, etc.
A partir de esta definición de instrucciones, requerimos una arquitectura básica para el DLX
capaz de ejecutar las operaciones que ejecuten las instrucciones. Posteriormente, mejoraremos
esta arquitectura básica a fin de resolver ciertos problemas de la segmentación (riesgos
estructurales)
Página 29
Arquitectura de Máquinas Computadoras III
Paralelismo y Arquitecturas Avanzadas
Rd Write
mdr
BR
DataBus
M
ir
Rf1 R
Rf2 R
mar
4
A
B
A
B
@Bus
pc
ALU
buff
Figura 2.4. Arquitectura básica del DLX
2.5
DIFICULTADES DE LA SEGMENTACION
Dado el alto rendimiento conseguido en una maquina segmentada, parece que cuanto mayor sea
k, mejor rendimiento obtenemos, sin embargo, la verdad es que la segmentación no es tan simple.
Existen situaciones en las que aparecen riesgos por dependencias que limitan la eficiencia del cauce.
Existen tres posibles casos: Riesgos por dependencias de recursos de las etapas, dependencias de datos
y dependencias de control debido a las instrucciones de saltos, según expondremos a continuación:
 Riesgos estructurales: Son conflictos o colisiones en un recurso de ejecución cuando
dos etapas diferentes intentan usarlo simultáneamente. Recordemos que cada etapa debe
tener hardware independiente para realizar su tarea, porque de lo contrario tendríamos
situaciones de competencia (race conditions), que si no se resuelven parquearían el
cauce. Para que un segmentado sea funcional estos riesgos deben resolverse desde el
mismo vuelven a nivel de diseño.
 Dependencias de datos: Surgen cuando el solapamiento de instrucciones pone en
riesgo la secuencia lógica resultados en un programa, por ejemplo, una instrucción Ij
posterior a Ii no puede continuar porque uno de sus operandos –que era resultado de Ii
no ha sido actualizado –
Página 30
Arquitectura de Máquinas Computadoras III
Paralelismo y Arquitecturas Avanzadas
 Dependencias de control: surgen de la segmentación de los saltos que cambian el valor
el PC.
Además, existe el problema de tratamiento de Excepciones (interrupciones síncronas) debido
a la existencia de múltiples instrucciones en ejecución de forma simultánea. Los riesgos en la
segmentación pueden hacer necesario detener el cauce. La diferencia principal entre
detenciones en una maquina segmentada y en una no segmentada se presenta porque hay
múltiples instrucciones ejecutándose a la vez. Una detención, en una maquina segmentada,
requiere con frecuencia que prosigan algunas instrucciones, mientras se retardan otras.
Normalmente, cuando una instrucción esta detenida, todas las instrucciones posteriores a esa
instrucción también se detienen. Las instrucciones anteriores a la instrucción detenida pueden
continuar, pero no se buscan nuevas instrucciones durante la detención. Una detención hace
que el rendimiento de la segmentación se degrade con relación al rendimiento ideal.
2.6
DEPENDENCIAS ESTRUCTURALES
Cuando se segmenta una máquina, la ejecución solapada de instrucciones requiere que
cada etapa sea especializada en una subtarea de la ejecución y cuente con recursos
independientes asociados a esa etapa, de lo contrario, el acceso simultáneo a un recurso puede
crear situaciones de competencia o race conditions durante la ejecución que no pueden
resolverse postergando el acceso, pues todas las etapas deben proceder al unísono.
La única forma de evitar los riesgos estructurales consiste en dirimir la competencia desde el
diseño mismo de la máquina, definiendo qué etapa tendrá la supremacía de cada recurso y
duplicando recursos si es necesario. Un segmentado sin riesgos estructurales resueltos no es
una máquina práctica, pues probablemente nunca logre funcionar.
Aunque muchos riesgos estructurales de la segmentación pueden detectarse a proiri por simple
inspección, –como en el caso del acceso a memoria en BUS y MEM, o el incremento del PC en
BUS y cálculo en ALU– para detectar y corregir todas las dependencias estructurales en forma
detallada, recurrimos a la Tabla de Reserva. La tabla de reserva es una herramienta útil para
analizar los recursos ocupados por cada etapa de la segmentación por lo cual se pueden
identificar fácilmente los riesgos y tomar las medidas de diseño para solventarlos.
2.6.1
TABLA DE RESERVA DEL DLX
La Tabla de Reservas es un instrumento muy útil en la detección y solución de riesgos
estructurales. En ésta se mapean las etapas del cauce en las columnas de la matriz contra las
instrucciones del segmentado que ocupan las filas. En cada celda en la intersección aparecen
tanto las acciones que debe ejecutar el procesador en cada la etapa de acuerdo a la instrucción
como los recursos que trata de ocupar la misma.
Instrucción
BUS
D/L
ALU
Página 31
MEM
ESC
Arquitectura de Máquinas Computadoras III
rd = rf1 op
rf2
OP
rd =
M(rf1+d)
LOAD
M(rf1+d) =
rf2
STORE
if (cond)
pc = pc + d
BRx
2.6.2
Paralelismo y Arquitecturas Avanzadas
mar = pc
mdr =
M(mar)
ir = mdr
pc = pc + 4
decodificar
A = rf1
buff = A op
B = rf2
B
mar = pc
mdr =
M(mar)
ir = mdr
pc = pc + 4
decodificar
A = rf1
B=d
mar = A + B
mar = pc
mdr =
M(mar)
ir = mdr
pc = pc + 4
decodificar
A = rf1
B=d
mdr = rf2
mar = A + B
mar = pc
mdr =
M(mar)
ir = mdr
pc = pc + 4
decodificar buff = A + B
A = pc
cond =
B=d
(A’ cmp
A’ = rf1
0)
-
rd = buff
mdr =
M(mar)
rd = mdr
M(mar) =
mdr
-
if (cond)
pc = buff
-
RIESGOS ESTRUCTURALES EN EL DLX
1. Sistema de Memoria: Probablemente el impacto más grande de la segmentación sobre los
recursos de la máquina esté en el sistema de memoria. Aunque el tiempo de acceso no haya
cambiado, el ancho de banda de la máquina debe incrementarse puesto que hay que
proporcionar dos accesos a memoria por cada ciclo de reloj: uno para instrucciones y el otro
para datos. En los RISC esto se resuelve implementando un sistema con dos caches, una
para datos y la otra para instrucciones.
2. Recursos de cálculo: Notamos 3 posibles riesgos en los órganos de cálculo del DLX :
 La etapa BUS requiere calcular el incremento del PC en 4 para lo cual solicitaría los
servicios de la ALU y a su vez, la etapa ALU requiere aplicar A OP B, para lo cual
solicita los servicios de la ALU.
 Por otro lado la instrucción BRx requiere comparar rf1 con 0 en la etapa ALU, lo cual
genera un conflicto incluso internamente dentro de la misma etapa (usar ALU para
ambas operaciones de forma secuencial sería inadmisible porque incrementaría la
duración del ciclo de máquina.
 Finalmente, al BR se solicitan dos lecturas y una escritura simultáneamente.
Página 32
Arquitectura de Máquinas Computadoras III
Paralelismo y Arquitecturas Avanzadas
Estos riesgos se solucionan:
 Se debe agregar un sumador a la etapa BUS para incrementar PC.
 Además de la ALU, en la etapa ALU se debe agregar un Comparador: cond = (A’ cmp
0)
 Se debe diseñar el BR para permitir dos lecturas al inicio del período y una escritura al
final del mismo.
3. Latches: Los latches, por regla general, deben leerse al principio del período y escribirse al
final de éste –garantizando la función de retención entre etapas– con lo cual los datos sólo
deben permanecer en estos durante un período. Por otro lado, sólo una etapa puede escribir
en cada uno de ellos, pues de otro modo podríamos tener competencia o colisión. En el
DLX, es necesario revisar las instrucciones para determinar cuándo aparecen dependencias
estructurales de uso de latches. Podemos establecer tres criterios para determinar y solventar
tales dependencias:
 Si se escribe en un latch en la etapa e y se lee hasta en la e+2 o posterior, se corre el
riesgo de perder el valor original. Esto ocurre en OP con buff y en STORE con mdr.
En este caso hay que duplicar latches para solucionar la dependencia.
 No se permite a dos etapas diferentes escribir en el mismo latch, se corre el riesgo
de provocar una colisión en el acceso al latch cuyo desenlace sería impredecible
(pues se deja al hardware definir cuál dato se escribirá de los dos ). Para resolver
esto, hay que usar diferentes latches como destino de escritura en cada etapa. El
único caso especial es el PC que puede escribirse en la etapa BUS y en MEM, sin
embargo aquí la competencia está disuelta por la precedencia del salto sobre la
secuencia y por tanto, en este caso, los posibles valores se multiplexan dejando como
trabajo a la unidad de control establecer cuál de ellos se escribe en PC.
 Las lecturas múltiples a un mismo latch por diferentes etapas no generan
dependencias ni tampoco las escrituras al mismo latch por la misma etapa de
diferentes instrucciones.
4. Información de la Instrucción en ejecución en cada etapa: El segmentado requiere saber
en cada momento qué instrucción se está ejecutando en cada etapa para poder genera las
señales de control, por tanto el IR debe multiplicarse a fin de propagar la instrucción a lo
largo del cauce. En el DLX, necesitamos, además del IR que se escribe en la etapa BUS,
réplicas IR2 en la etapa D/L, IR3 en la etapa ALU e IR4 en la etapa MEM.
Tabla 2.1. Resumen de Riesgos estructurales con sus soluciones.
Tipo de recurso
Riesgos
Página 33
Solución
Arquitectura de Máquinas Computadoras III
Paralelismo y Arquitecturas Avanzadas
Sistema de Memoria
Acceso a Memoria en BUS y MEM
Usar dos caches: una de instrucciones iCache en la
etapa BUS y otra de datos dCache en la etapa MEM
Recursos de Cálculo
Conflicto uso ALU: BUS para incrementar
PC, ALU para operar A y B y ALU para
comparar.
Usar un sumador en BUS (PC = PC+4)
usar una ALU en ALU (ALUout = A OP B)
usar un comparador en ALU (cond = A’ cmp 0)
Latches
Sobreescritura de latches
Colisión acceso a escritura simultánea
Duplicar latches.
El PC es caso especial: se multiplexa.
Instrucción en etapa
Perder la información de qué instrucción
se esta ejecutando en cada etapa.
Crear réplicas del IR en cada etapa excepto ESC
para propagar la Instrucción junto a sus datos.
2.6.3
TABLA DE RESERVA CON DEPENDENCIAS ESTRUCTURALES RESUELTAS
Instrucción
BUS
rd = rf1 op rf2
ir = Mi(pc)
pc = pc + 4
decodificar
A = rf1
B = rf2
ir2 = ir
mar = A op B
ir3 = ir2
mdrin = mar
ir4 = ir3
rd = mdrin
ir = Mi(pc)
pc = pc + 4
decodificar
A = rf1
B=d
ir2 = ir
mar = A + B
ir3 = ir2
mdrin = Md(mar)
ir4 = ir3
rd = mdrin
ir = Mi(pc)
pc = pc + 4
decodificar
A = rf1
B=d
mdr = rf2
ir2 = ir
mar = A + B
mdrout = mdr
ir3 = ir2
M(mar) = mdrout
ir4 = ir3
-
ir = Mi(pc)
pc = pc + 4
decodificar
A = pc
B=d
A’ = rf1
ir2 = ir
mar = A + B
cond =
(A’ cmp 0)
ir3 = ir2
OP
rd = M(rf1+d)
LOAD
M(rf1+d) = rf2
STORE
if (cond)
pc = pc + d
BRx
D/L
ALU
MEM
if (cond)
pc = mar
ir4 = ir3
ESC
-
Obviamente, estas modificaciones requieren rediseñar la estructura del Procesador para reflejar
todos estos cambios y poder detectar los requerimientos de control. Se denomina camino de
datos o DataPath al diagrama de la estructura del procesador, diseñado de forma tal que muestre
de forma clara la trayectoria que deben seguir los datos dentro del procesador.
Página 34
Arquitectura de Máquinas Computadoras III
2.6.4
Paralelismo y Arquitecturas Avanzadas
DATAPATH DEL DLX
DLX Datapath - Dependencias estructurales resueltas
Sistema de Memoria
Señales de Control
Reloj
R/W
BUS
@Inst
ICache:R/W
PC
iCache

4
Reloj
Inst
IR
(offset d)
D/L
BR
Rf1 R
Reloj
Reloj
Reloj
A'
BR:@Rf1(CO, R1), Read
BR:@Rf2(CO, R2), Read
MuxA(CO)
MuxB(CO)
Rf2 R
A
B
MDR
Reloj
IR2
ALU
0
ALUsel(CO)
ALU
Comp
Reloj
Reloj
Cond
Reloj
Reloj
MAR
MDROUT
IR3
R/W
MEM
@datos
dCache
dCache:R/W(CO)
datos_out
datos_in
Reloj
Reloj
MDRIN
IR4
ESC
Rd Write
BR:@Rd(CO, Rd|R2)
BR
Figura 2.5. Datapath del DLX con dependencias estructurales resueltas
Página 35
Arquitectura de Máquinas Computadoras III
2.7
Paralelismo y Arquitecturas Avanzadas
DEPENDENCIAS DE DATOS
Las lecturas y escrituras de los datos deben ejecutarse en el orden que establece la
secuencia lógica del programa. La segmentación permite iniciar la ejecución de instrucciones
posteriores antes que se completen las anteriores, con lo cual se corre el riesgo de leer o escribir
datos en un orden incorrecto si una instrucción j opera sobre los mismos registros que una
instrucción anterior i. Un buen diseño de procesador segmentado no debe permitir la ejecución
de estas instrucciones posteriores hasta que se pueda garantizar la coherencia de los datos.
Veamos un
ejemplo:
R1 se escribe aquí
Esc
(i) OP R1, R2, R3
D/L
(j) OP R5, R1, R7
Necesito el valor de R1 aquí
En este caso la instrucción j requerirá en la etapa D/L un dato que no será actualizado hasta tres
ciclos después. Si el programa continúa, los resultados no serían los esperados, por tanto el
encauzado deberá detener todas las etapas anteriores a D/L hasta que R1 se haya actualizado.
Estas detenciones del cauce, denominadas latencias, merman la eficiencia porque en estos
ciclos no se producen instrucciones. Las dependencias de datos deben tratarse tanto para evitar
resultados incoherentes como para minimizar las latencias que provocan pérdidas en el
desempeño del segmentado.
2.7.1
TIPOS DE DEPENDENCIAS DE DATOS
Formalmente, si llamamos dominio D a los operandos (lecturas) de una instrucción y recorrido
R a su resultado (escritura), podemos decir que existe dependencia de datos entre dos instrucciones
cuando la intersección ya sea del dominio o recorrido de la una de ellas con el dominio o recorrido de
la otra es diferente del conjunto vacío. Según esta definición podemos diferenciar cuatro tipos de
dependencias de datos posibles:
D(i)  D(j)
D(i)  R(j)
R(i)  D(j)
R(i)  R(j)




( simplificadamente
( simplificadamente
( simplificadamente
( simplificadamente
D-D o RAR)
D-R o WAR)
R-D o RAW)
R-R o WAW)
D-D: La instrucción j posterior trata de leer un dato antes que la instrucción i anterior lo haya
hecho. Desde el punto de vista de datos no representa problemas, sin embargo presupone
requerimientos estructurales (como varios buses o puestos de lectura en el banco de registro).
Esta dependencia suele llamarse RAR, como siglas de Read After Read.
Página 36
Arquitectura de Máquinas Computadoras III
Paralelismo y Arquitecturas Avanzadas
D-R: J trata de escribir un registro antes que una instrucción i anterior lo haya leído, violación
al orden Write After Read (WAR). Esta dependencia no ocurre en cauces lineales con ejecución
en orden, sin embargo puede ocurrir en cauces multiciclo cuando la ejecución ocurre en
desorden o en segmentados con ejecución dinámica.
R-D: Problema típico de los segmentados. Consiste cuando la instrucción j trata de leer datos
que no han sido escritos por la instrucción i anterior a ella, tratando de romper el orden Read
after Write o RAW. El ejemplo mostrado de dependencia con R1, es un caso típico de R-D :
R(i)  D(j)  , pues R(i)  D(j) = {R1}
R-R: No puede ocurrir en el DLX dado que sólo se escribe en una única etapa, pero básicamente
puede aparecer en cualquier segmentado donde se escriba en diferentes etapas ( Write After
Write o WAW).
Dados los alcances del curso, sólo enfocaremos las dependencias R-D por ser las más comunes
y las únicas que se presentan en nuestro modelo. Lectores interesados en le tema pueden
encontrar más material en las obras de Henessy y Patterson.
2.7.2
TRATANDO LAS DEPENDENCIAS DE DATOS EN EL DLX
Hay dos formas de tratar las dependencias de datos en el DLX: a nivel de mejora de diseño para
minimizar la penalización por latencias y a nivel de detención para evitar incoherencias. En el
DLX hay un máximo de 4 posibles latencias por dependencias.
Valor actualizado de R1
disponible aquí
R1 se escribe aquí
ALU
Esc
D/L
1ra Latencia
2da Latencia
3ra Latencia
4ta Latencia
Necesito el
valor de R1
aquí
2.7.2.1
MEJORAS DE DISEÑO:
 Garantizar que las lecturas ocurren luego de las escrituras del ciclo anterior (Esto se
garantiza estructuralmente en el DLX). Elimina la posible 4ª latencia.
 Usar la técnica de forwarding, bypassing o cortocircuito para adelantar el dato actual a
donde se requiere sin esperar a que esté escrito en el Banco de registros.
Página 37
Arquitectura de Máquinas Computadoras III
Paralelismo y Arquitecturas Avanzadas
Por ejemplo, Nótese que el valor de R1 en el ejemplo está disponible en la salida de la ALU de la
instrucción i, por tanto, ésta puede cortocircuitar con su entrada, permitiendo el manejo correcto del dato
mediante la selección de MuxA y MuxB en la instrucción j, eliminando así la 1ª latencia. Estos sólo
puede lograrse mediante un riguroso control pues nótese que aparentemente el valor de R1 se solicita al
inicio del ciclo y la salida de la ALU está disponible hasta el final del mismo, sin embargo recuérdese
que los registros A y B se escriben al final del ciclo también, por tantoel valor de la salida de la ALU
puede estar disponible con suficiente tiempo para escribir en A o B. esto es posible pues la instrucción
en la etapa D/L se tiene en el IR y la instrucción en ALU en el IR2 por tanto el control puede hacer el
cortocircuito inequívocamente.
También se pueden adelantar las salidas del MuxMDRin y del MDRin hacia MuxA y MuxB
a fin de eliminar las latencias 2 y 3 con la instrucción OP. Veamos en el ejemplo a continuación
cómo se darían estos cortocircuitos o adelantamientos:
Valor actualizado de R1
disponible aquí
R1 se escribe aquí
ALU
Mem
D/L
Esc
Cortocircuitos que adelantan
el valor de R1 eliminando las
posibles latencias para
operaciones como OP
ALU
Valor actualizado de R1
se ocupa aquí
Los cortocircuitos aplicados son:
OP(i) – OP(i+1) :
entrada
S(ALU)  E(A)|E(B)
Es decir, que la salida de la ALU se lleva a la
del registro A o del registro B (entrad de la ALU)
OP(i) - OP(i+2) :
OP(i) - OP(i+3) :
S(MAR)  E(A)|E(B)
En este caso, el valor de R1 ya está más próximo, se
lleva de la etapa MEM al inicio de la etapa ALU.
S(MDRin)  E(A)|E(B) R1 ya está en la etapa Esc pero no se escribirá hasta el
próximo ciclo por cuanto hay que adelantar la salida
de MDRin a la entrada de la ALU.
No todos los casos de dependencias de datos en el DLX se pueden resolver con cortocircuitos,
la dependencia LOAD(i) – OP(i+1), por ejemplo, no pueden tratarse con cortocircuitos pues no
hay suficiente tiempo para lograr Salida(MEM)  Entrada(ALU). Hay que buscar otras
técnicas en estos casos.
Valor actualizado
disponible aquí
ALU
MEM
D/L
Valor actualizado
requerido aquí
Página 38
Esc
Arquitectura de Máquinas Computadoras III
2.7.2.2
Paralelismo y Arquitecturas Avanzadas
INTERLOCK POR HARDWARE
Para los casos de implementación de DLX en que no se realizaron mejoras de diseño, y para los casos
en que las mejoras no permiten eliminar todas las latencias, se deben parar las inicializaciones del cauce
y esperar hasta que el resultado esté disponible.
Esto puede hacerse por hardware. La unidad de control puede disponer de un órgano de detección de
dependencias de datos que genere una señal cuando la nueva instrucción cargada en IR tiene
dependencia con alguna de las instrucciones en ejecución (comparación de los Rf en IR con los Rd en
IR2 .. IR4). Cuando se dé el caso de dependencia, entonces deberá congelarse la etapa BUS (no cargar
PC+4, pero sí si es destino de salto) e introducir NOP por hardware en IR2 a fin de insertar una burbuja
o ranura de retardo (delay slot) que permita esperar hasta que el resultado esté disponible en el banco de
registros para continuar con la instrucción postergada en IR.
2.7.2.3
TRATAMIENTO POR SOFTWARE
 Finalmente, el compilador o el programador a bajo nivel puede introducir ciclos sin
ejecución (de relleno) mediante la instrucción NOP.
 Otro método, propio para compiladores y más eficiente, consiste en reordenar las
instrucciones a fin de evitar las dependencias.
Página 39
Arquitectura de Máquinas Computadoras III
2.7.3
Paralelismo y Arquitecturas Avanzadas
RESUMEN DE DEPENDENCIAS DE DATOS EN EL DLX
Instrucciones
Involucradas
OP - OP
OP - LOAD
OP – STORE
CASO 1:
OP r1, r2, r3
STORE r5, d(r1)
OP – STORE
CASO 2:
OP r1, r2, r3
STORE r1, d(r4)
LOAD - OP
LOAD - LOAD
LOAD – STORE
CASO 1:
LOAD r1, d(r2)
STORE r5, d(r1)
LOAD – STORE
CASO 2:
Escenario
Tratamiento
OP(i) – OP(i+1)
OP(i) – OP(i+2)
OP(i) – OP(i+3)
OP(i) – LOAD(i+1)
OP(i) – LOAD (i+2)
OP(i) – LOAD (i+3)
OP(i) – STORE(i+1)
S(ALU)  E(A)|E(B)
S(MAR)  E(A)|E(B)
S(MDRin)  E(A)|E(B)
S(ALU)  E(A)
S(MAR)  E(A)
S(MDRin)  E(A)
S(ALU)  E(A)
OP(i)
(i+2)
–
STORE S(MAR)  E(A)
OP(i)
(i+3)
–
STORE S(MDRin)  E(A)
OP(i) – STORE(i+1) S(ALU)  E(MDR)
OP(i)
(i+2)
–
STORE S(MAR)  E(MDR)
OP(i)
(i+3)
–
STORE S(MDRin)  E(MDR)
LOAD(i) – OP(i+1)
Parar el cauce:
IR=OP y IR2=LOAD y IR2(Rd)= (IR(Rf1) | IR
(Rf2))
LOAD(i) – OP(i+2)
S(Md)  E(A)|E(B)
LOAD(i) – OP(i+3)
S(MDRin)  E(A)|E(B)
LOAD(i)
– Parar el cauce:
LOAD(i+1)
IR=LOAD y IR2=LOAD y IR2(Rd)=IR(Rf1)
LOAD(i) – LOAD S(Md)  E(A)
(i+2)
LOAD(i) – LOAD S(MDRin)  E(A)
(i+3)
LOAD(i)
– Parar el cauce:
STORE(i+1)
IR=STORE y IR2=LOAD y IR2(Rd)=IR(Rf1)
LOAD(i)
– S(Md)  E(A)
STORE(i+2)
LOAD(i)
– S(MDRin)  E(A)
STORE(i+3)
LOAD(i)
– S(Md)  E(MDRout)
STORE(i+1)
Página 40
Arquitectura de Máquinas Computadoras III
OP r1, r2, r3
STORE r1, d(r4)
STORE
Cualquiera
OP – BRx
LOAD – BRx
BRx - Cualquiera
LOAD(i)
STORE(i+2)
LOAD(i)
STORE(i+3)
- NO HAY
BRx va a cambiar
Paralelismo y Arquitecturas Avanzadas
– S(MDRin)  E(MDRout)
– S(MDRin)  E(mdr)
(Con la solución de riesgos de control)
NO HAY
Página 41
Arquitectura de Máquinas Computadoras III
2.7.4
Paralelismo y Arquitecturas Avanzadas
DATAPATH DEL DLX CON DEPENDENCIAS DE DATOS RESUELTAS
DLX Datapath - Dependencias de datos resueltas
Sistema de Memoria
Señales de Control
Reloj
R/W
BUS
Ld_PC
@Inst
ICache:R/W
PC
iCache

Ld_IR
4
Reloj
Inst
IR
D/L
(offset d)
BR
(a, b, c)
Rf1 R
Rf2 R
(a, b, c)
NOP
(a, b, c)
Reloj
Reloj
A'
A
Reloj
B
MDR
Reloj
BR:@Rf1(IR), Read
BR:@Rf2(IR), Read
MuxA'(IR, (IR3, IR3, IR4))
MuxA (IR, (IR3, IR3, IR4))
MuxB (IR, (IR3, IR3, IR4))
MuxMDR(IR, (IR3, IR3, IR4))
Ld_PC(IR, IR2)
Ld_IR(IR, IR2)
MuxIR2(IR, IR2)
IR2
ALU
0
ALUsel(IR2)
Comp(IR2)
MuxMDRout(IR2, IR3)
(b)
Comp
ALU
(a)
Reloj
Cond
Reloj
Reloj
MAR
MDROUT
Reloj
IR3
MEM
R/W
@datos
dCache
dCache:R/W(IR3)
MuxPC(IR3,Cond)
MuxMDRin(IR3)
datos_out
datos_in
Reloj
(b)
MDRIN
Reloj
IR4
ESC
(c)
Rd Write
BR:@Rd(IR4), Write
BR
Nota: Los cambios respecto al DataPath con Dep. Estructurales resueltas se muestran en azul fuerte
Figura 2.6. Datapath del DLX con dependencias de datos resueltas
Página 42
Arquitectura de Máquinas Computadoras III
2.8
Paralelismo y Arquitecturas Avanzadas
DEPENDENCIAS DE CONTROL
Las dependencias de control en los segmentados son introducidas por las instrucciones
de salto, BRx en el caso específico del DLX. Nótese que la instrucción de salto, actualiza el
valor del PC hasta en la etapa MEM, por tanto las instrucciones cargadas en el cauce deben
eliminarse del mismo pues su ejecución sería inválida si la condición resultase verdadera y el
salto se hiciera efectivo. El gran problema consiste en que estas instrucciones podrían cambiar
el estado del procesador generando resultados inesperados, por tanto, el procesador debería
bloquear la carga de nuevas instrucciones hasta que se actualice el valor del PC correctamente,
lo cual genera 3 latencias por cada instrucción de salto:
if (cond) ir = Mi(pc)
pc = pc + pc = pc + 4
d
decodificar
A = pc
B=d
A’ = rf1
mar = A + B if (cond)
cond =
pc = mar
(A’ cmp
0)
-
BRx
PC
BRx
i
MEM
k
Consideremos que en un programa típico, los saltos representan entre un 15% y un 30% de las
instrucciones, por tanto, las dependencias de control, deben considerarse muy seriamente
porque degradan el desempeño del segmentado de forma significativa.
Ejemplo: Supongamos que en un programa, el 20% de instrucciones son BRx e idealicemos
diciendo que no hay paradas por dependencias de datos, entonces nuestro ciclo de máquina real,
viene a ser:
r = 0.2 ( + 3) + 0.8 1.6 
Nota: El ciclo de máquina se incrementa en un poco más del 50%.
2.8.1
ADELANTANDO LA DEFINICION DEL SALTO
Mejorando el diseño, podemos adelantar el salto a la etapa ALU. Esto no implica ningún
requerimiento especial y elimina una latencia.
Página 43
Arquitectura de Máquinas Computadoras III
Paralelismo y Arquitecturas Avanzadas
PC
BRx
ALU
i
Según
el
anterior, el ciclo
real, con el adelantamiento es:
ejemplo
máquina
k
de
r = 0.2(  + 2) + 0.8 1.4 
if (cond) ir = Mi(pc)
pc = pc + pc = pc + 4
d
decodificar
A = pc
B=d
A’ = rf1
mar = A + B
if = (A’ cmp 0)
pc = A + B
-
-
BRx
Sin embargo, todavía es una penalización grande. ¿Podemos mejorar? – ¿Qué tal si tratamos
de pasar el salto a la etapa D/L, para tener sólo una latencia?
PC
BRx
i
D/L
k
Este adelantamiento implica ciertos requerimientos estructurales:
 Se necesita un sumador adicional en la etapa D/L.
 Debe pasarse el comparador de la etapa ALU a la etapa D/L.
 Como D/L es la etapa más rápida, lo más seguro es que no se requiera agrandar .
En este caso el ciclo real de máquina debido a la penalización por saltos viene a ser:
r = 0.2 ( + ) + 0.8 1.2 
if (cond) ir = Mi(pc)
pc = pc + pc = pc + 4
d
decodificar
if = (Rf1 cmp 0)
pc = pc + d
-
-
-
BRx
El salto no puede adelantarse más debido a que Rf1 debe leerse del BR. Las mejoras obtenidas
son equivalentes a las obtenidas con las dependencias de datos. Como conclusión: No siempre
podemos evitar las latencias debido a cierta combinación de instrucciones y éstas implicarán
una merma en el desempeño del DLX.
Página 44
Arquitectura de Máquinas Computadoras III
Paralelismo y Arquitecturas Avanzadas
Los adelantamientos, modifican la estructura de la instrucción BRx y con ello, las posibles
dependencias de datos entre ésta y el resto de instrucciones.
Por otro lado, es necesario que el procesador provea un mecanismo de parada por hardware
para tratar la latencia, o en su defecto, el programador o el compilador deberán introducir un
NOP explícitamente después de cada BRx. El segmentado puede tratar el interbloqueo a nivel
de unidad de control introduciendo NOP en la entrada del IR cuando se ha decodificado un
BRx, de forma tal que
en el próximo
PC
ciclo, IR2 = BRx e
IR=NOP.
BRx
D/L
i
i+1
k
If (Rf1 cmp 0) : PC = @Salto
else: PC = PC + 4
@Salto
R/W
@Inst
iCache
PC

NOP
4
Reloj
Inst
IR
Figura 2.7. Implementación del interbloqueo por hardware en el DLX
2.8.2
DEPENDENCIAS DE DATOS EN BRx TRAS ADELANTAMIENTO A D/L
Como anotamos anteriormente, el adelantamiento de la instrucción BRx provoca nuevas
dependencias, que no fueron tratadas en el apartado anterior. En la tabla a continuación se
resumen:
Instrucciones
Involucradas
OP - BRx
LOAD - BRx
Escenario
Tratamiento
S(ALU)  E(Cmp) Debe estudiarse si
queda tiempo para que se dé, caso
contrario, parar.
OP(i) – BRx (i+2)
S(MAR)  E(Cmp)
OP(i) – BRx (i+3)
S(MDRin)  E(Cmp)
LOAD(i) – BRx(i+1) Parar el cauce:
IR=BRx y IR2=LOAD y IR2(Rd)= IR(Rf1)
OP(i) – BRx(i+1)
Página 45
Arquitectura de Máquinas Computadoras III
2.8.3
Paralelismo y Arquitecturas Avanzadas
LOAD(i)
(i+2)
–
LOAD(i)
(i+3)
–
BRx S(Md)  E(Cmp) Debe estudiarse si
queda tiempo para que se dé, caso
contrario, parar.
BRx S(MDRin)  E(Cmp)
TRATAMIENTO DE LAS LATENCIAS DE CONTROL
Como no podemos eliminar una latencia debido a saltos, podemos implementar técnicas para
tratar de evitarlas en algunos casos. Existen tres técnicas empleadas:
 Salto retardado (método Software)
 Apuesta por una de las ramas (Software+Hardware)
 Apuesta por ambas ramas (BTB)
2.8.3.1
Salto retardado
Este método es aplicable en tiempo de compilación cuando la máquina no es capaz de bloquear
el cauce por hardware. Consiste en buscar instrucciones de relleno útiles que se ejecuten en
lugar del NOP obligado antes que el salto se haga efectivo. Es equivalente al reordenamiento
de código en caso de dependencias de datos.
Sin embargo, la elección de las instrucciones de relleno no es trivial pues requiere de un análisis
previo de las dependencias de datos entre instrucciones. La primera opción consiste en buscar
una instrucción anterior como relleno, esta no debe tener ninguna dependencia con las
siguientes del bloque. Si no se logra obtener una instrucción apropiada del bloque básico, se
puede emplear una del bloque de continuación o del de salto, siempre que cumplan ciertas
condiciones de independencia de datos y su ejecución no afecte la lógica del programa (por
ejemplo, que no escriba resultados a memoria y que el registro destino sea un registro temporal
donde no importe el valor actualizado por la instrucción).
En el caso de rellenar con una instrucción de continuación, si el salto no se hace efectivo, la
instrucción elegida es útil. En cambio si lo es, se ha garantizado que aunque la ejecución de la
instrucción de relleno no es útil, no perjudica los resultados. Esta estrategia se prefiere cuando
el salto es poco probable, por ejemplo en implementaciones de IF-ELSE. En caso de usarse
relleno desde el bloque de salto, la ejecución de la instrucción de retardo es útil si el salto es
efectivo. Esta elección es preferida cuando el salto es muy probable, como en estructuras de
bucles. Si no se detectan instrucciones de relleno válidas (cuya ejecución en caso de fallo no
sea perjudicial) debe rellenarse con NOPs.
Página 46
Arquitectura de Máquinas Computadoras III
Ejemplo:
…
1) MUL R1, R2, R9
2) ADD R7, R1, R9
3) DIV R7, R1, R9
4) SUB R4, R4, R6
5) BRx R4, d
Paralelismo y Arquitecturas Avanzadas
Bloque básico
(i)
Continuación
6) MUL R5, R13, R13
7) SUB R15, R7, R8
8) SUB R12, R5, R6
…
Salto
(i+1)
9) SUB R12, R7, R1
(k)
10) ADD R13, R12, R5
11) ADD R6, R5, R6
…
En este trecho de código, podemos emplear como relleno la instrucción 3 del bloque básico
pero no 1 o 4 porque tienen dependencias R-D ni 2 pues tiene dependencia R-R con 3 (No debe
tener ningún tipo de dependencia con las siguientes de su bloque). Por otro lado, del bloque
de continuación, no debe tener dependencias de ningún tipo con las instrucciones anteriores
de su bloque ni R-D con las del bloque de salto, por tanto solo es elegible 7 (6 tiene R-D con
10 y 11. 8 tiene con 6 y R-R con 7), Finalmente del bloque de salto, la instrucción no debe
tener dependencias con las anteriores de su bloque ni R-D con las del bloque de continuación,
por tanto sólo 9 es apropiada. (10 tiene R-D con 9 y 11 tiene R-D con 8)
2.8.3.2
Apuesta por una de las dos ramas
Esta técnica es una mejora al simple interlock por hardware mencionado anteriormente,
consiste en definir en el diseño del segmentado que se apueste por una de las dos ramas del
salto y permitir mediante control, evitar cambios en el estado del programa cuando la apuesta
es fallida (inhabilitar las escrituras o abortar la ejecución con NOPs). Esta técnica requiere de
soporte de software para el caso de apuesta por la rama de salto.
Si se apuesta por el bloque de continuación, la ejecución de la instrucción que sigue a un BRx
continúa hasta que el se actualiza PC, aquí la Unidad de Control puede saber si el salto fue
efectivo [IR2 = BRx y (Rf1 cmp 0 = verdadero)] y por tanto Bloquear la instrucción: IR = NOP
o dejarla que ejecute bloqueando las escrituras en MEM y BR. Si el salto no fue efectivo, no se
hace nada y no hay latencias.
Si se apuesta por el bloque de salto, el compilador inserta las instrucciones necesarias del bloque
de salto (1 en el DLX), en caso de fallo, se anula la ejecución (bloqueando las escrituras) o se
Página 47
Arquitectura de Máquinas Computadoras III
Paralelismo y Arquitecturas Avanzadas
aborta con NOP en IR. Nótese que la responsabilidad del relleno útil descansa sobre el
compilador o el programador en lenguaje de bajo nivel.
Con esta técnica se eliminan las latencias cuando hay aciertos. Una mejora a esta técnica es la
predicción del salto, que resulta muy conveniente por el carácter cíclico de los mismos. Se
requiere almacenar el comportamiento de los saltos para predecir si se toma el salto o no. Se
implementa en firmware y necesita pre-decodificación de las instrucciones de salto. Las
penalizaciones se reducen significativamente.
2.8.3.3
Apuesta por ambas ramas (BTB)
Esta última técnica también aprovecha el carácter repetitivo de los saltos. Se agrega al
procesador un Branch Target Buffer (BTB) o buffer de destino del salto que es una memoria
asociativa donde se almacenan las últimas direcciones de destino de salto y con un MUX se
selecciona la instrucción correcta (cargada de memoria= i+1, o cargada desde el BTB = k).
El procesador siempre procede por el bloque de continuación. Si el salto se toma, debe buscar
la dirección destino en el BTB. La primera vez, seguramente no estará guardada en el buffer y
se deberá anular la ejecución de la instrucción cargada i+1 mediante NOP en IR.
Si la condición de salto es verdadera y @salto está en el BTB, se selecciona la instrucción de
salto k en el MUX y el PC se carga con @salto + 4 para la próxima carga.
Página 48
Arquitectura de Máquinas Computadoras III
2.8.4
Paralelismo y Arquitecturas Avanzadas
DATAPATH DEL DLX CON LAS DEPENDENCIAS DE CONTROL RESUELTAS
DLX Datapath - Dependencias de datos resueltas
Sistema de Memoria
R/W
ICache:R/W
PC
iCache
BUS
PC + 4
Ld_PC
@Inst
Señales de Control
@Salto
Reloj
NOP

Ld_IR
4
Reloj
Inst
PC
0
IR
D/L

@salto
BR
(a, b, c)
d
@Salto
Rf1 R
(offset d)
Rf2 R
(a, b, c)
(a, b, c)
Comp
Reloj
Reloj
Cond
A
NOP
B
MDR
Reloj
BR:@Rf1(IR), Read
BR:@Rf2(IR), Read
Cmp(IR); @Salto(IR)
MuxCmp(IR, (IR3, IR3, IR4))
MuxA (IR, (IR3, IR3, IR4))
MuxB (IR, (IR3, IR3, IR4))
MuxMDR(IR, (IR3, IR3, IR4))
Ld_PC(IR, IR2)
Ld_IR(IR, IR2)
MuxIR(IR)
MuxIR2(IR, IR2)
IR2
ALU
ALUsel(IR2)
MuxMDRout(IR2, IR3)
(b)
ALU
(a)
Reloj
Reloj
MAR
MDROUT
Reloj
IR3
MEM
R/W
@datos
dCache
dCache:R/W(IR3)
MuxMDRin(IR3)
datos_out
datos_in
Reloj
Reloj
(b)
MDRIN
IR4
(c)
ESC
Rd Write
BR:@Rd(IR4), Write
BR
Nota: Los cambios respecto al DataPath con Dep. de Datos resueltas se muestran en azul fuerte
Figura 2.8. Datapath del DLX con las dependencias de control resueltas
Página 49
Arquitectura de Máquinas Computadoras III
2.9
Paralelismo y Arquitecturas Avanzadas
EXCEPCIONES
2.9.1
INTRODUCCION
Las interrupciones son mecanismos que permiten el desvío (o suspensión momentánea) del
flujo en ejecución debido a la necesidad de atención de algún evento. Estas pueden clasificarse en
asíncronas y síncronas.
 Asíncronas: ocurren en cualquier momento y no dependen del flujo actual de ejecución,
por ejemplo las solicitudes de atención de los dispositivos de entrada/salida.
 Síncronas: aparecen como efecto de situaciones excepcionales ocurridas durante la
ejecución de una instrucción, por lo cual algunos autores les llaman excepciones.
Ejemplo de excepciones son el fallo de bloque de caché, el overflow y la división por
cero.
Cuando ocurren las primeras, el procesador guarda el estado de la máquina (generalmente el
PC) y fuerza un trap en próximo ciclo a fin que la próxima instrucción que se carga es la primera
de la rutina del sistema que trata las interrupciones, de esta manera las instrucciones en el cauce
se terminan de ejecutar y no ocurren latencias de ningún tipo.
En el caso de las excepciones, el problema es que ocurren durante la ejecución de una
instrucción que puede abortarse debido a la excepción o debería recomenzarse después que la
rutina de tratamiento de interrupciones concluya.
2.9.2
EXCEPCIONES EN EL DLX
En el DLX, pueden aparecer excepciones en las etapas BUS, MEM (acceso a caché),
D/L (código de operación ilegal) y ALU (excepciones aritméticas). Las primeras deben ser
recomenzables en tanto las últimas por lo general abortan la ejecución de la instrucción o del
programa y la rutina de tratamiento del sistema o el sistema operativo se encargan de tratarlas.
Cuando ocurre una excepción en el DLX, éste debe:
 Forzar una instrucción de trap en la etapa BUS, en el siguiente ciclo. Esta instrucción
se encarga de invocar a la rutina de tratamiento de excepciones del sistema.
 Hasta que el trap sea efectivo, se deben inhibir todas las escrituras para la instrucción
que generó la excepción. y las instrucciones posteriores a ellas, evitando así que se
cambie el estado de la ejecución y se obtengan resultados erróneos.
 Una vez que el trap comienza a ejecutarse, el DLX debe guardar el valor del PC de la
instrucción que generó el fallo, para poder recomenzarla. En máquinas donde se
implementa el salto retardado, el valor del PC no puede determinarse de forma
secuencial y por tanto es necesario guardar réplicas del PC a lo largo de todo el cauce
para poder recomenzar la ejecución de las instrucciones.
Página 50
Arquitectura de Máquinas Computadoras III
Paralelismo y Arquitecturas Avanzadas
Cuando la rutina de tratamiento de interrupciones se concluye, hay que recomenzar las
instrucciones que se estaban ejecutando en el momento de la excepción. Esto puede hacerse
reinicinado el PC con la dirección de la instrucción que generó la excepción y los PC’s a
continuación de ésta en caso de saltos.
Si un procesador puede inhibir toda la ejecución de las instrucciones siguientes a la causante de
la excepción, tratar la excepción y recomenzar la ejecución volviendo a cargar la instrucción
que causó el fallo, se dice que tiene tratamiento preciso de excepciones. Esto es deseable en
muchos procesadores.
Pero no siempre tenemos un panorama tan limpio, pues pueden surgir mayores complicaciones cuando
se presentan múltiples excepciones. El caso más complicado es cuando instrucciones posteriores
generan sus excepciones antes que las anteriores, de forma tal que tratarlas no es un caso tan trivial como
cuando hay una sola excepción en el cauce. Se aplican dos técnicas:
a) Tratar las excepciones en el orden de las instrucciones (vector de status de excepciones): El
procesador se auxilia de un vector de estatus que se arrastra con cada instrucción. Cuando
aparece una excepción, se inhiben las escrituras de esta instrucción y sus sucesores y el cauce
sigue avanzando, En el final de la etapa MEM, siempre se verifica el vector de status, y si hay
excepciones se tratan y se reinicia esa instrucción. Esto nos garantiza que las excepciones se
traten de forma precisa.
b) Tratar las excepciones en el orden de aparición, lo cual requiere detener no solo los sucesores
sino los antecesores que puedan cambiar el estado de la máquina. Una vez resuelta la excepción
se inicia en la instrucción más antigua que se detuvo.
Página 51
Arquitectura de Máquinas Computadoras III
Paralelismo y Arquitecturas Avanzadas
2.10 SEGMENTACION NO LINEAL
La segmentación lineal se caracteriza por un estricto orden de precedencia en la
ejecución de las subtareas del cauce, lo cual puede expresarse mediante un grafo de precedencia
lineal. La segmentación no lineal o general, es aquella que permite ciertas flexibilidades en el
orden y forma de ejecución de estas subtareas y se caracteriza por un grafo no-lineal.
out
in
T1
1
T3
2
T2
3
3
out
1
T4
in
T1
T2
T3
2
Grafo de Precedencia Lineal
T4
4
Grafo de Precedencia No lineal
Figura 2.9. Grafos de precedencia
En la segmentación lineal, representada por el primer gráfo, el flujo de datos o tareas pasa por todas y
cada una de las etapas en el orden de las mismas una sola vez. En la segmentación no lineal, dependiendo
de la función del cauce, las tareas pueden:






No pasar por todas las etapas.
Tener múltiples puntos de entrada y salida
Estar en posibilidad de pasar por (ocupar) varias etapas a la vez.
Tener caminos alternativos según se requiera en la ejecución.
Repetir el paso por una etapa de manera cíclica (procesadores multiciclo).
Repetir el paso por una etapa ocupada varios ciclos atrás (retroalimentación o feed back).
Nótese que la segmentación lineal está relacionada con cauces de instrucción y los no lineales o
generales, con cauces del tipo aritmético o de procesamiento de vectores. Los enlaces entre las etapas
del cauce nos permiten identificar si son lineales o no. El diagrama de bloques es un esquema
simplificado del cauce al cual se ha despojado de los detalles de acoplamiento (latch) y temporización.
En en las figuras 8 y 9 pueden apreciarse las diferencias entre los diagramas de bloque de un cauce
lineal y uno no lineal.
S1
S2
S3
S4
S5
Figura 2.10. Diagrama a bloques de un segmentado lineal.
S1
S2
S3
S4
S5
Figura 2.11. Diagrama a bloques de un segmentado no-lineal.
Los círculos con signos de conmutación al centro, son multiplexores. Estos permiten seleccionar la
entrada correcta a cada etapa en cada ciclo de reloj. Es obvio que dadas las posibilidades de feedback
Página 52
Arquitectura de Máquinas Computadoras III
Paralelismo y Arquitecturas Avanzadas
del cauce, pueden existir muchos caminos o trayectorias de cada tarea. Esto es particularmente cierto en
cauces con caminos alternativos o reconfigurables ya sea de manera estática o dinámica.
2.11 PROCESADORES MULTICICLO
Algunos procesadores implementan operaciones especiales como aritmética en punto
flotante o vectorial para mejorar las prestaciones de la máquina. Muchas de estas operaciones,
pueden emularse con rutinas de software pero su desempeño es muy pobre, por otro lado,
implementarlo en hardware ha requerido de procesadores auxiliares dedicados a este fin pues,
estas operaciones son intensivas y requieren mucho tiempo para completarse, por ejemplo, una
división en punto flotante requiere de 30 a 50 ciclos de máquina.
Para que tales operaciones sean implementables en un segmentado, se requeriría que las
instrucciones pudieran ocupar repetidamente la ALU hasta completar la operación y luego
continuar con la ejecución. A simple vista, esto nos causaría tremendas latencias, sin embargo,
dado que la multiplicidad involucra solo una etapa, se suele multiplicar la ALU en diversas
unidades, permitiendo a algunas tener una instrucción repitiéndose en esta etapa varios ciclos
hasta completarse mientras el proceso de ejecución continúa normalmente. A una máquina que
soporte tal dinámica de trabajo se le llama Procesador Multiciclo.
Una modificación del DLX para soporte a operaciones en punto flotante, deberá ser multiciclo.
El esquema de la figura 10 muestra el diagrama a bloques del DLX Multiciclo, con varias
unidades funcionales, básicamente ALUs especializadas en operaciones enteras y/o de punto
flotante.
ALU
E
MUL
E/PF
BUS
D/L
MEM
ESC
SUM
PF
DIV
E/PF
Figura 2.12. DLX multiciclo.
Con los procesadores Multiciclo hay que tener en cuenta que pueden aparecer riesgos R-D.
Con resultados de operaciones en punto flotante, también podrían aparecer riesgos de datos del
tipo R-R.
Para controlar el acceso a las etapas de la ALU, es necesario llevar un registro de su uso así
como de los registros involucrados en las instrucciones. Las diferentes unidades funcionales
de la ALU se controlan mediante un Scoreboard o marcador que tiene un bit de ocupado para
Página 53
Arquitectura de Máquinas Computadoras III
Paralelismo y Arquitecturas Avanzadas
cada etapa así como el registro destino de la operación. Esta técnica es clave para la detección
dinámica de dependencias de datos. Cuando se carga una nueva instrucción se debe comprobar
en el marcador que la unidad a utilizar no esté ocupada, caso contrario se inhibe emisión de la
instrucción en la etapa D/L. Para evitar los riesgos R-R, se debe llevar una secuencia de las
escrituras, permitiendo re-expedición interna en registros temporales e inhibiendo la escritura
de los resultados finales hasta que se garantice el orden en la etapa MEM.
2.12 PLANIFICACION DE RECURSOS
Las dependencias estructurales en los cauces generales consisten en la posibilidad de colisiones
por el intento de uso de una etapa por más de una tarea. Estas dependencias se atacan haciendo una
buena planificación de los recursos que evite las colisiones. A diferencia de la solución de dependencias
estructurales en los cauces lineales, los cauces generales no pueden evitar latencias.
A continuación explicaremos el procedimiento de planificación basado en secuenciamiento de trabajos
y prevención de colisiones. Esta planificación tiene dos objetivos: evitar inicialización de tareas que
generarán colisiones y definir una estrategia de secuenciamiento de trabajos que busque la utilización
óptima del cauce.
Iniciemos con un ejemplo. Usemos el cauce de la figura 9 y definamos su tabla de reserva. En los cauces
generales, necesitamos una tabla para cada función. Por simplificación sólo consideraremos cauces
monofunción en nuestro curso. La tabla de reserva se conforma por las etapas del cauce vs períodos de
tiempo o ciclos que requiere la función para completarse. Una marca en el cuadrado, en la intercepción
de Sj con Ti, muestra si la etapa Sj es ocupada por la función F en el ciclo Ti.
Sj \Ti
0
1
X
2
3
4
1
2
3
4
5
6
7
8
X
X
X
X
X
X
5
X
X
X
Figura 2.13. Tabla de reserva del cauce
Así vemos cómo la función F, ocupa en el primer ciclo (0) la etapa 1, pasa a la 2 en el segundo, se
mantiene en esa etapa en el tercero, pasa a la tercera, la cuarta, repite la cuarta, pasa a la quinta, en la
cual dependiendo de alguna condición, puede pasar a la segunda y luego terminar en la primera o repetir
la quinta y pasar a terminar en la primera.
En función de esta tabla, se pueden definir latencia como el número de ciclos de tiempo entre dos
iniciaciones. El fin del procedimiento de planificación por secuenciamiento de trabajos consiste en
elegir una estrategia de control que consiste en una secuencia de latencias, que minimice la latencia
media entre iniciaciones.
Se inicia por determinar la tabla de reserva y la lista de inicializaciones prohibidas F y libres F’. Son
inicializaciones prohibidas aquellas que generan colisiones. El procedimiento recomienda detectar filas
con varias marcas (X) y restar el ciclo menor Ti del mayor Tj, el resultado serán las latencias prohibidas.
Página 54
Arquitectura de Máquinas Computadoras III
Paralelismo y Arquitecturas Avanzadas
Las libres son las latencias no prohibidas o conjunto complemento de F. Para nuestro ejemplo, estas
son:
F = { 1, 5, 6, 8 }
F’ = { 2, 3, 4, 7 }
El siguiente paso consiste en determinar el vector de colisiones C. Este es un arreglo de bits que tiene
en Ci un 0 si la iniciación es libre y un 1 si es prohibida en el ciclo i ( 0 si i pertenece a F’ y 1 si pertenece
a F). La longitud del vector es n, donde n = máx { Fi } por tanto, Cn = 1 siempre es verdad. Formalmente:
C = (Cn . . . C1) donde Ci = 1  i  F  Ci = 0  i  F’
En nuestro caso: C = ( 10110001)
Nótese que la nomenclatura empleada no es la de un vector matemático sinó la de un registro binario.
Esto tiene su razón, en realidad la estrategia de control se implementa en un registro de desplazamiento
por la derecha. Al iniciar el cauce por primera vez, se carga el vector de colisiones en el registro y en
cada ciclo se desplaza un bit a la derecha, así sólo se inicia una nueva tarea en el ciclo k si la salida
serial del registro es 0. El registro se recarga con C cuando la latencia es n.
Para caracterizar la dinámica de las iniciaciones sucesivas en el cauce, se emplea un diagrama de estado
que tiene por estado inicial a C. Cada nuevo estado se forma con el despazamiento de k ciclos del estado
inicial aplicando un OR binario con C, para todo ciclo k que sea libre. El lazo de transición de estados
muestra cuántas latencias (desplazamientos) se requieren para llegar a ese estado. Cada estado nuevo
genera otros estados con todas sus iniciaciones libres hasta que regresan al estado inicial.
Para el ejemplo:
Partiendo del vector de colisiones o estado 1:
 Desplazamos 2 posiciones y enmascaramos con C mediante OR:
00101100
(OR) 1 0 1 1 0 0 0 1
10111101


 Estado 2 ( con latencia 2)
Obtuvimos el estado 2. De manera similar, desplazando 3 y 4 obtenemos los estados 3 y 4 .
Desplazando 7, se regresa al estado 1.
00010110
00001011
(OR)1 0 1 1 0 0 0 1
(OR) 1 0 1 1 0 0 0 1
1 0 1 1 0 1 1 1  Estado 3
1 0 1 1 1 0 1 1  Estado 4
( con latencia 2)
( con latencia 4)
Luego, tomamos el estado 2 y aplicamos desplazamiento 2 generando el estado 5. El
desplazamiento 7 retorna al estado 1:
00101111
(OR)1 0 1 1 0 0 0 1
1 0 1 1 1 1 1 1  Estado 5
(OR)
Página 55
00000001
10110001
1 0 1 1 0 0 0 1  Estado 1
Arquitectura de Máquinas Computadoras III
Paralelismo y Arquitecturas Avanzadas
( con latencia 2)
( con latencia 7)
De manera similar se generan los otros desplazamientos con los otros estados. Resultan 5 estados
solamente. La figura 2.6.7. muestra el Diagrama de estados concluído.
7+
1
10110001
7+
7+
3
4
7+
7+
2
3
2
10110111
3
10111101
4
2
4
10111011
5
10111111
Figura 2.14. Diagrama de estados
Los ciclos en el diagrama muestran las secuencias de latencias sostenibles de régimen permanente sin
colisiones. Se denomina ciclo simple a aquella trayectoria que no repite estado excepto el origen-destino.
La latencia media de un ciclo es la suma de las latencias entre la cantidad de ellas. La máxima
productividad se logra en una secuencia que involucre ciclos con la mínima latencia media mlm, el
número máximo de Xs en una línea es la cota inferior a la mlm. Un ciclo simple es avaricioso si cada
latencia en el ciclo es la mínima de cada estado que pasa (verificar arcos salientes) y su latencia media
es menor o igual al número de prohibidas y mayor o igual a la mlm. Una buena estrategia de control
involucra ciclos avariciosos. Abajo se resumen los resultados para nuestro ejemplo:
Ciclo simple
(7)
( 3, 7 )
( 3, 4 )
( 4, 3, 7 )
( 4, 7 )
( 2, 7 )
( 2, 2, 7 )
( 3, 4, 7 )
Latencia media
7
5
3.5
4.6
5.5
4.5
3.6
4.6
Avaricioso
SI, tiene la mlm
3 ARQUITECTURAS SIMD
3.1
3.1.1
INTRODUCCIÓN
Necesidad de procesamiento de Vectores y matrices:
Página 56
SI
Arquitectura de Máquinas Computadoras III
Paralelismo y Arquitecturas Avanzadas
A finales de los 50 e inicios de los 60, se incrementó la demanda de procesamiento
automatizado para cálculos científicos. Estos requieren procesar vectores y matrices, a
menudo de gran tamaño.
Un gran inconveniente surgió con los modelos secuenciales de la época, pues las arquitecturas
y lenguajes de programación secuenciales tienen un desempeño muy pobre en este tipo de
operaciones que regularmente se simulan mediante ciclos, obteniendo tiempos de respuesta
prohibitivos para la mayoría de las aplicaciones requeridas.
Un ejemplo claro es la multiplicación de matrices que involucra tres ciclos anidados con lo
cual cada incremento de M o N multiplica los ciclos por dos factores, lo que nos resulta en un
algoritmo exponencial del orden O(n3).
t
n
FOR I = 1 TO N
FOR J=1 TO M
C [I, J] = 0.0
FOR K=1 TO L
C
[I,
C[I,J]+A[I,K]*B[K,J]
END FOR
END FOR
ENDFOR
J]
La necesidad, impulsó a los diseñadores de Computadoras a tratar de interpretar de mejor
manera el comportamiento de estas estructuras de datos. Para ello se consideró útil hacer un
análisis de las características del procesamiento de vectores / matrices y sus exigencias. El
resultado fue un conjunto de máquinas de alto coste, desempeño y una enorme capacidad de
cálculo (que varía de máquina a máquina) que asignaremos a la clasificación SIMD de la
taxonomía de Flynn (aunque algunos autores señalan que solo un espécimen de la familia: el
processor array es SIMD).
3.1.2
Características y exigencias del procesamiento de Vectores / Matrices
Características:
 Colección o arreglo de datos.
 Se almacenan en celdas contiguas en la memoria.
 Independencia de datos (operación en elemento[i, j] no depende de resultado en [i-1, j1]).
 Una misma operación sobre todo el conjunto de datos.
Exigencias:
 Diferentes tipos de operaciones
o f1: V  V (VSQRT, VCOMP –complemento, VSIN, VCOS )
o f2: V  E (VSUM –Sumatoria de elementos, VMAX, VMIN)
Página 57
=
Arquitectura de Máquinas Computadoras III
Paralelismo y Arquitecturas Avanzadas
o f3: V x V  V (VADD, VMP –Multiplicación de vectores o matrices)
o f4: V x E  V (SMUL – Escalación del vector, SADD –Desplazamiento)
o f5: V x V  E (SMP –Producto punto de vectores)
 Manejo de operandos vectoriales y escalares (Instrucciones de máquina vectoriales o
vectorización por compilador)
 Algoritmos idóneos
 Ejecución a alta velocidad
3.2
Tipos de Arquitecturas SIMD
3.2.1
Procesadores vectoriales o Vector Processors
 Las características y exigencias del procesamiento vectorial son propias para la ejecución
segmentada, básicamente porque se eliminan las dificultades de la segmentación (no riesgos
estructurales, de datos o control) permitiendo tener el cauce lleno y generando resultados a par
de elementos por ciclo.
 Obviamente surgen nuevas exigencias en cuanto al flujo de datos de entrada y la recepción de
salida.
 Los procesadores vectoriales son arquitecturas que tienen cauces para procesamiento de
vectores.
Página 58
Arquitectura de Máquinas Computadoras III
3.2.2
Paralelismo y Arquitecturas Avanzadas
Procesadores matriciales o Array Processors
Los procesadores vectoriales, requieren
diferentes esquemas de ejecución cuando procesan
matrices.
Un enfoque más acertado consiste en tener una red
o matriz de procesadores o unidades de ejecución
(EP) con registros y/o memoria local gobernados
por un procesador o unidad de control central.
Al ejecutar una instrucción, la unidad de control
emite a todos las mismas señales de control
(broadcast) sincrónicamente y los EPs ejecutan
todos la misma operación sobre sus datos locales.
3.3
Procesadores vectoriales Encauzados
(Vector Processors)
3.3.1
Cauces vectoriales







Cauces aritméticos.
Supercomputadores Vectoriales / Procesadores vectoriales Asociados
Entradas: Vector –Vector o Vector-Escalar.
Salida a Vector o Escalar.
Requieren registros especiales para control de la longitud del vector.
Formato especial de instrucción
Esquemas o métodos de procesamiento para tratamiento de matrices
o Procesamiento horizontal (filas: izq  der)
o Procesamiento vertical ( columnas: arriba  abajo)
o Procesamiento en bucle ( ciclos de sub-matrices )
 Tiempo de retardo de inicialización o preparación del cauce y de paso o flushing.
 Entrada de datos/Recepción de salida a alta velocidad.
o Desde Memoria (Requerido acceso rápido)
o Usar registros vectoriales
3.3.2
Maquinas M-M, Memorias entrelazadas y Procesamiento en flujo continuo
 Los operandos vectoriales residen siempre en memoria.
 Alto tiempo de preparación (típico ~20 cycles)
 Se requieren memorias de alta velocidad, ideal: entregar un par de datos y recibir un resultado
por ciclo.
 Uso de memorias entrelazadas. ( búsqueda + ráfaga = entrega datos por ciclo) 
Procesamiento en flujo continuo.
Página 59
Arquitectura de Máquinas Computadoras III
Paralelismo y Arquitecturas Avanzadas
 Alto
rendimiento para vectores grandes,
pobre para vectores pequeños.
 Formato requiere especificar direcciones en memoria de los vectores y en algunas máquinas
con palabras variables, el incremento o tamaño del elemento así como el tamaño del vector.
COP
3.3.3
V1
V2
Vr
Incr
Tam
Máquinas R-R y Encadenamiento de vectores.





Empleo banco de registros vectoriales. (además del escalar)
Carga de Memoria a registros de alta velocidad.
Menor tiempo de preparación y en general menor ciclo de máquina que la M-M.
Tamaño restringido de los registros vectoriales (64, 72, 128 elementos)
Ejecución en partes para vectores largos: Alto desempeño en vectores pequeños y pobre en
largos.
 Predominan sobre las M-M.
 Formatos de instrucción usan directamente registros vectoriales / escalares (Instrucciones de
carga) o direcciones de memoria y registros a emplear. Algunos ejemplos:
COP
COP
RV1
RV1
RV2
@V2
Incr
RVr
Tam
Tam
 Enmascaramiento y vectores binarios.
 Usualmente tienen múltiples Cauces vectoriales (Unidades funcionales) y Escalares.
Página 60
Arquitectura de Máquinas Computadoras III
Paralelismo y Arquitecturas Avanzadas

CAUCE 1
UNIDAD DE
PROCESAMIENTO DE
INSTRUCCIONES
(IPU)
BANCO DE
REGISTROS
ESCALARES
CAUCE 2
CAUCE n
Procesador
Escalar
MEMORIA
PRINCIPAL
CONTROLADOR DE
INSTRUCCIONES
VECTORIALES
Procesador
Vectorial
CAUCE V1
BANCO DE
REGISTROS
VECTORIALES
CAUCE V2
CONTROLADOR DE
ACCESO VECTORIAL
CAUCE Vn
 Múltiples UF: Prefetch + Ejecución simultánea de varias instrucciones  Tratar potenciales
dependencias de datos (R-D)
 Encadenamiento de cauces: ejecución paralela de varias instrucciones con dependencia R-D.
3.4
Procesadores SIMD (Processor Arrays)
3.4.1






Procesadores de arreglos de EPs.
Arreglos de EPs.
Verdaderas máquinas SIMD.
Introducidas en los 70’s, auge en finales de los 80’s.
Requieren gran estructura de EPs para ser eficientes.
Tiempo de ejecución de la instrucción matricial fijo (vs te = n+p+fluss del Vector P. )
Estructuras de interconexión - Comunicación EPs, Memoria y E/S: Topología.
Página 61
Arquitectura de Máquinas Computadoras III
Paralelismo y Arquitecturas Avanzadas
 Memoria de alta velocidad para cargar las caches o registros de EPs.
3.4.2
Enmascaramiento, limitando la estructura.
 Los EPs pueden Habilitarse o deshabilitarse desde la UC.
 Esto permite limitar la estructura para ajustarse al tamaño de la matriz.
 Equivalente a control de tamaño de vector en VPs.
3.4.3
Importancia de VLSI en las Arquitecturas SIMD.
 VLSI permite integración de alta densidad
 Ejemplo: MasPar MP-1: Processor Board: 32 chips de 32 MP-1 con su 64Kb memoria y control
en 4 pies cuadrados. Se puede configurar en redes de n x n o de n x 2n. La mínima
configuración involucra 1,024 procesadores y la máxima 16,384.
3.5
3.5.1
Procesadores Sistólicos
Deficiencias de la taxonomía de Flynn.
Existen arquitecturas paralelas que no caben en la Taxonomía de Flynn. Paradójicamente,
mientras por un lado, existe vacuidad en una categorización, por otro hay ambigüedad en la
posible clasificación de algunas máquinas.
Algunos autores, apegados al sentido estricto de Instrucción, declaran vacía la clasificación
MISD, en tanto otros, que se basan en las operaciones que se aplican en el procesamiento del
data stream más que en la instrucción completa en sí, identifican a los cauces aritméticos
como arquitecturas de esta categoría. También los arreglos sistólicos que estudiaremos en
seguida son a menudo clasificados en este grupo.
Por otro lado, aunque algunos asumen que el VP es SIMD (punto de vista de la instrucción),
otros los clasifican como simples SISD por cuanto la operación se aplica de forma repetida al
conjunto de datos en diferentes instantes de tiempo.
Los MIMD están todos agrupados en una categoría única que reúne máquinas de muy
diferente potencia de cálculo, complejidad de diseño y coste.
Finalmente, se ha propuesto un estilo de computación sobre una arquitectura multiprocesador
que ejecute el mismo programa sobre diferentes conjuntos de datos y que los Procs. se
sincronicen peródicamente (Para tal estilo de computación se ha propuesto la categoría Single
Program Multiple Data)
Página 62
Arquitectura de Máquinas Computadoras III
3.5.2
Paralelismo y Arquitecturas Avanzadas
Arreglos sistólicos
 Concepto introducido por Kung y colegas (Carnegie-Mellon)
 Sistólico porque la memoria funciona como el corazón, inyectando datos al arreglo en
cada pulso de reloj
 Consigue mejoras de procesamiento sin necesidad de incrementar el ancho de banda
de la memoria
MEMORIA
MEMORIA
P
EP
Procesador convencional





EP
EP
EP
Matriz Sistólica
Cauce en formación matricial con múltiples flujos de datos.
Conjunto de celdas simples (Unas sola operación con entradas y Registro).
Control e interconexión simples (No Broadcasting)
Datos fluyen de forma encauzada, estructurada y son accesibles sólo en las fronteras.
Interconexión en matriz o árbol.
EP
EP
EP
EP
EP
EP
EP
EP
EP
EP
EP
EP
EP
Matriz Cuadrada
EP
EP
EP
EP
EP
EP
EP
EP
EP
EP
EP
EP
Matriz Hexagonal
Arbol sistólico
 Aritmética Matricial de alto nivel: Multiplicación, Inversión, Desc, L-U
 Fácil de expandir (VLSI simple)
 Desventaja: Limitado por la velocidad de E/S
Ejemplo de un Procesador sistólico (De Rafiquzzaman – Pág. 312).
X0
X
0
Y
Z=W*X+Y
W2
0
W1
0
W0
W
2
Fig 1: Celda EP del procesador
sistolico
1
Fig 2: Estructura de Interconexion del
Procesador sistolico
Página 63
0
Arquitectura de Máquinas Computadoras III
3.6
Paralelismo y Arquitecturas Avanzadas
Procesadores de Frente de Onda
3.6.1
Redes sincrónicas vs. redes asíncronas
 Los AP: Broadcasting síncrono. Requieren Memorias de alta velocidad.
 Matrices asíncronas: Proceder hasta que el dato esté disponible.  Esperar a memoria.
3.6.2
WaveFront Array Processor
 Celdas simples y comunicación simple
(similar al sistólico).
 Cuando hay datos válidos en las entradas, la
celda de dispara (computa) y expande el
resultado a las salidas.
 Recibe su nombre por analogía con los frentes
de onda ( sonido, perturbación en agua, etc)
3.7
B21
B22
B11
B12
A12
A11
0
0
A22
A21
0
0
Procesadores Asociativos
3.7.1
Procesadores Asociativos
 Procesadores paralelos basados en estructuras de datos asociativas (Memorias
asociativas, por lo general)
 Su nivel de paralelismo se mide en bit-{serie|paralelo},palabra-{serie|paralela}
 Aplican la misma instrucción sobre todos los datos cuya clave satisface los parámetros
o argumentos de búsqueda.
 En la actualidad estas arquitecturas han dado pie a nuevos paradigmas
computacionales con soporte de hardware para bases de datos y aplicaciones que
demandan procesamiento paralelo de conjuntos de datos.
3.7.2
Ejemplares
Primeros: PEPE (Burrogs Corp., 1972) y STARAN (Goodyear, 1972. Construído para la
Marina USA, orientado al procesamiento de objetos de radar). Posteriormente:
procesadores asociativos masivamente paralelos para apoyo en campos y aplicaciones
específicos tales como RDBMS (RAP, Neocore LCC) e Inteligencia Artificial (AM3,
IXM2).
Página 64
Arquitectura de Máquinas Computadoras III
3.8
Paralelismo y Arquitecturas Avanzadas
Estructuras y algoritmos para Procesadores Matriciales.
3.8.1
Estructuras de Interconexión – Comunicación EPs.
 Necesaria una estructura que interconecte todos los EPs.
 Decisiones de diseño:
o Modo de operación: Sincrónica – Asíncrona
o Estrategia de Control: Centralizado o Distribuido.
o Metodología de Comunicación: Conmutación de Circuitos o Conmutación de
Paquetes.
o Topología de Red: Estáticas – Dinámicas
3.8.2
Características de los Algoritmos matriciales.
 Complejos
 Reproducen el comportamiento natural de la estructura de dato
 Ganancia significativa sobre homólogo secuencial
Ejemplos:
o Multiplicación de matrices.
 Secuencial es O(n3)
 Con vectores: O(n2) Carga de vectores, barrer filas por columnas.
- Ganacia es n.
 Con SIMD con hipercubos: O(n log2 n)
- Ganacia poco más que n
 Con SIMD y Computación VLSI : O(n)
- Ganacia n2
o Clasificación O(n) vs. O( n log2 n) de los secuenciales.
o Transformada rápida de Fourier FFT, ganancia es M2/log2
Página 65
Arquitectura de Máquinas Computadoras III
Paralelismo y Arquitecturas Avanzadas
4 ARQUITECTURAS MIMD.
4.1. Introducción a los MIMD: Multiprocesadores
Un Sistema Multiprocesador puede definirse como una comunidad de procesadores en
la misma computadora que cooperan para completar una tarea.
Por otro lado, es necesario hacer notar que aunque un sistema común usa un IOP o una FPU
que son en sí procesadores, estos no se consideran Multiprocesador por cuanto cada uno de los
procesadores auxiliares tiene una sola tarea específica y no son capaces de ejecutar programas
del usuario.
Con los sistemas multiprocesadores:
 Puede hacerse múltiples trabajos en paralelo
 Puede dividirse un trabajo en múltiples tareas paralelas
Concepto: Sistema que consta de 2 o más CPU interconectadas para permitir la ejecución de
múltiples tareas en paralelo. (n instrucciones en n procesadores ejecutándose a la vez)
Nivel de Paralelismo o granularidad:
Cuatro niveles de paralelismo:
 Nivel de tareas (Job Level): Diferentes procesos son asignados a diferentes
procesadores. Incluso se pueden asignar hilos de ejecución de un mismo proceso a
diferentes procesadores. A este nivel se le denomina de Granularidad gruesa. En este
nivel el control de la asignación de los procesos o los hilos de ejecución es asumido por
el sistema operativo.
 Nivel de Programa (Program level): Cuando diferentes procesadores pueden ejecutar
diferentes secciones de un mismo programa en paralelo. Existen varias posibilidades:
Rutinas completas, tramos de instrucciones independientes y diferentes iteraciones de
un ciclo sobre datos independientes (como matrices, por ejemplo). Este nivel se
considera de Granularidad fina. Es importante notar que en este caso es frecuente tener
datos compartidos. La asignación paralela de los tramos de programa en este caso los
puede definir el compilador, el programador a bajo nivel y el sistema operativo. (En
algunos sistemas MP, el programador o el compilador pueden definir explícitamente
que una rutina, conjunto de instrucciones o cada simple instrucción se ejecute y en
diferentes procesadores, es más, se puede definir inclusive en qué procesador se desea
la ejecución de ésta. Este enfoque tan fino no siempre es ventajoso porque atenta contra
una de las bondades de los MP: redundancia que permite gracefull degradation)
 Nivel de instrucciones (Instruction Level): Este nivel es más intimo a la organización
del procesador y ocurre en el caso específico de los procesadores encauzados, donde la
Página 66
Arquitectura de Máquinas Computadoras III
Paralelismo y Arquitecturas Avanzadas
ejecución de varias instrucciones se efectúa en diferentes etapas del procesador de forma
solapada en el tiempo (Granularidad más fina).
 Nivel de Aritmética y bits. (Bit Level): En este nivel, el paralelismo se verifica a nivel
aritmético, es decir, tenemos varios procesadores trabajando en paralelo sobre diferentes
secciones de bits de los datos en sí (especie de SIMD a nivel de bits) Este tipo de
procesadores se compone de enlaces de varios bit-slice processors. (Nivel de más fina
granularidad)
Para el caso de los sistemas MP, son comunes los dos primeros niveles de paralelismo. La figura
a continuación ilustra el caso del primer nivel comparando un sistema monoprocesador y uno
MP con procesos:
P
P1
P2
P3
Pr
Pr
Pr
Pr
Pr
Pr
Pr
Pr
Sistema
Monoprocesador
4.1
Sistema
Multiprocesador
Clasificación de los sistemas MIMD.


Sistema Fuertemente Acoplado o de M Compartida (Reales MP según Bell).
Sistema Débilmente Acoplado, de Memoria distribuída o Multicomputadores (según
Bell).
La principal diferencia estriba en cómo se interconectan. Para que puedan compartir la
memoria, se requiere una estructura de interconexión fuertemente acoplada, como por ejemplo
un bus común. Otra principal diferencia es cómo intercambian información y cómo están
controlados o sincronizados.
- Los primeros son más fáciles de construir y pero presentan limitaciones respecto a la cantidad
de procesadores concurrentes: Problema del ancho de banda de los MP con memoria común:
 Implementar memoria local en los “processing environments” o cachés.
 Mencionar problemas de diseño con cachés MP: política de escritura (write through
vs write back) y coherencia.
4.2
Estructuras de Interconexión.
Exponer el concepto de Estructura de Interconexión.
Hacer referencia y remembranza de los requerimientos señalados en las SIMD.
Página 67
Arquitectura de Máquinas Computadoras III
4.2.1
Paralelismo y Arquitecturas Avanzadas
Bus común.
La manera más sencilla de interconectar varios CPUs con una Memoria común (que puede estar
formada por varios bancos a la vez)
es mediante un Bus común. Esto
permite tener algunos IOPs también.
P1
P2
P3
P4
El problema
grande de este
acercamiento es eque la memoria se
convierte en cuello de botella,
requiriendo gran ancho de banda en
el acceso a memoria o limitando la
cantidad máxima de contendientes
M1
M2
IOP
IOP
por el bus. Una medida paliativa
muy eficaz consiste en definir una
jerarquía de memoria de al menos
MIMD con Estructura de interconexión
dos niveles.
Muchos MP de
empleando Bus común
memoria compartida suelen emplear
pequeñas memorias locales además
de uno o dos niveles de cache.
El uso de una memoria compartida de gran tamaño, organizada en bancos o módulos, también
puede aprovecharse para “paralelizar” el acceso a la memoria mediante entrelazamiento,
permitiendo un acceso “encauzado” a la memoria. Otra solución a la necesidad de ancho de
banda consiste en el ensanchamiento del ancho del bus de datos para permitir mayor velocidad
de transferencia hacia las cachés. También puede crearse puertos a cada banco con lo cual
podría accederse en paralelo a diferentes módulos de la misma Memoria principal o mejor aún,
múltiples accesos al mismo módulo. En los siguiente párrafos veremos cómo se han
aprovechado estas posibilidades mediante nuevas estructuras de interconexión.
Página 68
Arquitectura de Máquinas Computadoras III
4.2.2
Paralelismo y Arquitecturas Avanzadas
Conmutador Barra-Cruz.
Otra manera de interconectar los CPUs con la memoria, si ésta es modular, consiste en
emplear una estructura de interconexión en forma de una malla de conmutación de circuitos.
La figura muestra un conmutador barra-cruz típico.
Existen buses de conexión de cada
procesador a cada módulo de memoria. En las
intersecciones de las barras o buses, existen
conmutadores capaces de unir una barra
horizontal con una vertical creando un bus
particular entre el procesador y el módulo. En
cualquier instante cualquier procesador puede
adquirir acceso a un módulo que no esté
ocupado por otro procesador. En el caso que dos
procesadores deseen acceder al mismo módulo al mismo tiempo, éstos se bloquearán
mutuamente. En ese caso uno tendrá que reintentar luego. Para lograr este objetivo, se
implementan políticas de arbitraje que definen cual procesador tiene prioridad en caso de
bloqueo.
4.2.3
Memorias Multipuerto
Aunque el enfoque sencillo del
conmutador barra-cruz es muy simple y
relativamente de bajo costo, las políticas de
arbitraje pueden hacerlo complejo o ineficiente.
En arquitecturas más demandantes se
han diseñado memorias que permiten n accesos
concurrente, para lo cual están provistas de n
puertos de acceso. La figura muestra este
esquema de conexión. Estas memorias son muy
ventajosas en caso de pocos CPUs y casi
inviables cuando la cantidad de puertos
requeridos crece. De hecho, no son escalables,
es decir, que la cantidad de CPUs del MP está
limitada a los puertos disponibles en las
Memorias.
Como todo elemento que permite
interconexión completa, su costo es muy
elevado.
Página 69
M1
M2
P1
IOP
P2
IOP
P3
P4
MIMD con Estructura de interconexión
mediante Memorias Multipuerto
Arquitectura de Máquinas Computadoras III
4.2.4
Paralelismo y Arquitecturas Avanzadas
Redes Interconexión multietapa.
Las estructuras de interconexión anteriores son relativamente simples. Heredando de las
SIMD, algunos diseñadores de MPs han empleado redes de conmutadores para interconectar
CPUs y Módulos de memorias. Estas redes deben garantizar el acceso único a un módulo en
cualquier momento (arbitraje) para evitar race conditions y por tanto se diseñan como redes de
múltiples etapas. Los nodos de estas redes son dispositivos de conmutación denominados
conmutadores de intercambio. La figura a continuación muestra la estructura de un conmutador
de intercambio. Estos permiten en cualquier momento enrutar cualquiera de sus entradas a
cualquiera de sus salidas que no se encuentre ocupada. Otra vez, se debe definir la prioridad de
cada entrada. Se emplea un bus de control de 1 bit asociado a cada entrada, que indica la salida
a la que queremos conmutar.
0
1
La figura abajo muestra un tipo de red multietapa denominada red delta, por su forma
triangular. Otras redes más complejas permiten caminos alternativos a módulos que no han sido
ocupados. Por ejemplo la red omega. (Investigar la red omega). En cada red multietapa, existen
parámetros que se pueden calcular para poder definir de antemano: cantidad de Conmutadores,
etapas y enlaces necesarios, de acuerdo a la cantidad de CPUs y Módulos de Memoria.
4.2.5
Hipercubo.
Esta red se aplica mayormente a MPs de memoria distribuida y a algunos SIMD. Es una
red de conmutación de paquetes. En este caso, los nodos de la misma no son conmutadores sino
CPUs con su memoria local e inclusive I/O propia. El hipercubo es una red eficiente y escalable.
Presenta algunos retos al diseñador como la asignación de direcciones para los CPUs. Las
direcciones se asignan en forma de cadenas de bits. Un principio establece que dos nodos
contiguos solo diferencian su dirección uno del otro en 1 bit. Esto permite establecer algoritmos
de asignación de direcciones sencillos así como algoritmos de enrutamiento de paquetes o
mensajes. La figura abajo muestra la construcción escalable de hipercubos de 1 a 4 dimensiones.
Página 70
Arquitectura de Máquinas Computadoras III
4.3
Paralelismo y Arquitecturas Avanzadas
Acceso a recursos compartidos
En los MPs ce memoria compartida, existen obviamente, problemas de concurrencia:
 Estructura de interconexión: Se emplean métodos de arbitraje.
 Acceso a regiones y estructuras de memoria compartidas: Es necesario sincronización
de regiones críticas: Acceso exclusivo de los recursos. Uso de gates, pinlocks y
semáforos.(ver exclusión mutua)
4.3.1
Arbitraje del bus
La Arquitectura de bus común es muy sencilla y de bajo costo. Requiere acceso exclusivo,
durante un período de tiempo, por tanto se requiere Arbitraje: lógica y controlador que
concede el bus a un dispositivo específico:
Arbitraje fijo: Arbitraje paralelo (Codificador/Decodificador de prioridades)
Arbitraje serial
(Cadena de margaritas)
Arbitrio dinámico: Estructura dinámica y/o algoritmo.

4.3.2
Otras estructuras de interconexión tienen sus propios esquemas (revisar barra-cruz, red
multietapa, etc)
Exclusión mutua
Concurrencia de ejecución  acceso a estructuras de datos y SO que son compartidas. Para
garantizar la coherencia  acceso debe ser mutuamente excluyente. Soporte por SO y Hw:
Página 71
Arquitectura de Máquinas Computadoras III



4.4
Paralelismo y Arquitecturas Avanzadas
Gate o puerta: Puerto de acceso a una estructura compartida.
Semáforo: Indicador de acceso.
Pinlock o seguro: Componente Hardware que garantiza TEST&SET atómico.
Comunicación entre Procesadores

Es necesario definir formas de comunicación y sincronización de Procesadores en un
sistema MP.

Uso de puertos de E/S

En un MP de memoria compartida, se puede emplear un área de memoria como
exchange de mensajes. Cada MP puede poner mensajes, procedimientos o solicitudes
a otros o chequear si tiene nuevas solicitudes o mensajes dirigidos a él, para esto se usa
polling de Bits de estado que indican el contenido del buzón, de forma periódica.

Una mejora consiste en el uso de Interrupciones entre procesadores.(por programa)

Uso de un bus alternativo al bus del sistema.
En MP débilmente acoplados, la comunicación mediante la red: E/S. Paso de Mensajes:
 Se enrutan mensajes.
 Importante, la eficiencia de la red.
4.5
Coherencia de cachés
En sistemas de bus común, el tráfico y el cuello de botella debido al mismo en el bus, se puede
aliviar significativamente con el uso de cachés. La concurrencia impone altos requisitos a estas
cachés. El principal de ellos es resolver el problema de la coherencia de caché.
Escenario: Varios procesadores ejecutan hilos de un código reentrante que comparte algunas
variables globales. Estas variables son accedidas y actualizadas por todos los procesadores.
Cada vez que un procesador actualice, los demás deben tener noción de ello, pues las copias
quedan incoherentes entre sí.
Existen varios métodos o protocolos de solución de este problema:
En el primero, se resuelve la situación evitando el problema. El algoritmo estático,
implementado por compilador, asigna el acceso para actualizar a un dato compartido a un solo
procesador en un momento dado, por lo cual, no ocurre el problema.
Página 72
Arquitectura de Máquinas Computadoras III
Paralelismo y Arquitecturas Avanzadas
En el segundo bloque se encuentran varios protocolos de “sondeo” o snoopy protocols, que
permiten a encuestar los estados de los procesadores antes de realizar la actualización.

Uso de un bit de bandera (dirty bit). Cada vez que un procesador va a actualizar su copia,
pone en 1 un bit e interrumpe a los otros para que no actualicen su copia hasta que el
concluya su trabajo, en cuyo caso aquellos sondean el bit periódicamente hasta que el
primero actualiza la M, y el resto refresca su copia. Este esquema se emplea con política
write through y genera bastante tráfico en el bus.

El segundo esquema, llamado MESI, permite tener perfecto control de los estados de
la caché mediante un diagrama de estados que se va generando dinámicamente en el
funcionamiento de la caché. Revisar en Stallings detalles.
4.6
Sistemas Operativos y lenguajes de programación MP
4.6.1
Sistemas operativos:
SO para MP debe estar específica y especialmente diseñado para administrar esa arquitectura.



Administrar la concurrencia
Manejar la exclusión mutua
asignación de recursos y tareas
Modelos de asignación de recursos (lo hace el SO)
Master-Slave
SO separados
SO Distribuido o flotante
Para garantizar graceful-degradation, un sistema de diagnósticos es imprescindible (muchas
veces es un procesador auxiliar). Esto se implementa tanto en el arranque como en tiempo de
ejecución.
4.6.2
Lenguajes:
Varias formas de explotar el paralelismo:



Dejarle el trabajo al OS.
Lenguajes y compiladores que permiten paralelización de los programas secuenciales.
Lenguajes y compiladores que permiten al usuario escribir código con instrucciones
paralelas.
Página 73