Download - Folle to 2014

José Leónidas Díaz Chow Díaz - Medrano

IS 2013

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 2014

IS 2014

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 2014

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 Medida de rendimiento .......................................................................................... 2 1.1.2 Métricas de desempeño .......................................................................................... 2 1.1.3 Consideraciones de efectividad-costo .................................................................... 3

1.1.4 Técnicas de análisis de desempeño ........................................................................ 4 1.1.5 Rendimiento: .......................................................................................................... 4 1.1.6 Factores que determinan el tiempo de ejecución ................................................... 6 1.1.7 Ley de Amdahl ....................................................................................................... 6

1.1.8 Cálculo del tiempo de Ejecución............................................................................ 8 1.1.9 Métricas populares de rendimiento ........................................................................ 9

1.2 REDUCCIÓN DEL TIEMPO DE EJECUCIÓN ....................................................... 12

1.2.1 Reducción del período de reloj. ........................................................................... 12

1.2.2 Reducción de la cantidad de instrucciones N. ...................................................... 12 1.2.3 Reducción del CPI................................................................................................ 13

1.2.4 Consecuencias de la ley de Amdahl ..................................................................... 13

1.3 MEJORAS AL SISTEMA DE MEMORIA ............................................................... 15

1.3.1 Jerarquía de memoria ........................................................................................... 15 1.3.2 Principio de localidad de referencia. .................................................................... 16 1.3.3 Cálculo de la aceleración del rendimiento en la jerarquía de memoria ............... 16

1.4 MEJORAS AL SISTEMA DE ENTRADA-SALIDA ............................................... 17

1.4.1 DMA .................................................................................................................... 18

1.4.2 Procesadores y Canales de E/S ............................................................................ 18

1.5 INTRODUCCIÓN AL PARALELISMO ................................................................... 18

1.5.1 Procesamiento paralelo ........................................................................................ 19 1.5.2 Diferentes mecanismos y técnicas de mejora del desempeño empleadas ............ 19

1.6 CLASIFICACIÓN DE LAS ARQUITECTURAS PARALELAS. ............................ 21

2 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


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 TIPOS DE DEPENDENCIAS DE DATOS ........................................................ 36 2.7.2 TRATANDO LAS DEPENDENCIAS DE DATOS EN EL DLX ...................... 37

2.7.3 RESUMEN DE DEPENDENCIAS DE DATOS EN EL DLX ........................... 40

2.7.4 DATAPATH DEL DLX CON DEPENDENCIAS DE DATOS RESUELTAS . 42

2.8 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 INTRODUCCION ............................................................................................... 50

2.9.2 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 ............................................ 57

3.1 INTRODUCCIÓN ...................................................................................................... 57

3.1.1 Necesidad de procesamiento de Vectores y matrices: ......................................... 57

3.1.2 Características y exigencias del procesamiento de Vectores / Matrices .............. 57

3.2 Tipos de Arquitecturas SIMD ..................................................................................... 58

3.2.1 Procesadores vectoriales o Vector Processors ..................................................... 58 3.2.2 Procesadores matriciales o Array Processors ....................................................... 59

3.3 Procesadores vectoriales Encauzados (Vector Processors) ........................................ 59

3.3.1 Cauces vectoriales ................................................................................................ 59 3.3.2 Maquinas M-M, Memorias entrelazadas y Procesamiento en flujo continuo ...... 59

3.3.3 Máquinas R-R y Encadenamiento de vectores.................................................... 60

3.4 Procesadores SIMD (Processor Arrays) ..................................................................... 61

3.4.1 Procesadores de arreglos de EPs. ......................................................................... 61 3.4.2 Enmascaramiento, limitando la estructura. .......................................................... 62 3.4.3 Importancia de VLSI en las Arquitecturas SIMD. ............................................... 62


3.5 Procesadores Sistólicos ............................................................................................... 62

3.5.1 Deficiencias de la taxonomía de Flynn. ............................................................... 62 3.5.2 Arreglos sistólicos ................................................................................................ 63

3.6 Procesadores de Frente de Onda ................................................................................. 64

3.6.1 Redes sincrónicas vs. redes asíncronas ................................................................ 64 3.6.2 WaveFront Array Processor ................................................................................. 64

3.7 Procesadores Asociativos ........................................................................................... 64

3.7.1 Procesadores Asociativos ..................................................................................... 64

3.7.2 Ejemplares ............................................................................................................ 64

3.8 Estructuras y algoritmos para Procesadores Matriciales. ........................................... 65

3.8.1 Estructuras de Interconexión – Comunicación EPs. ............................................ 65

3.8.2 Características de los Algoritmos matriciales. ..................................................... 65

4 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. ..................................................................................... 68

4.2.1 Bus común. ........................................................................................................... 68 4.2.2 Conmutador Barra-Cruz. ...................................................................................... 69

4.2.3 Memorias Multipuerto ......................................................................................... 69 4.2.4 Redes Interconexión multietapa. .......................................................................... 70 4.2.5 Hipercubo. ............................................................................................................ 70

4.3 Acceso a recursos compartidos ................................................................................... 71

4.3.1 Arbitraje del bus ................................................................................................... 71

4.3.2 Exclusión mutua ................................................................................................... 72

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 Sistemas operativos: ............................................................................................. 73 4.6.2 Lenguajes: ............................................................................................................ 73


Página 1

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 2

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 3

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 4

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 5

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 6

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 7

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

ntt

n

ttg

)1(*)1(**

y:

n

t

tA

mejorado

g

)1(

1

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 8

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

i

Ci

t1

*

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:

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:

j

g

j

j nct **1

I

c

CPI

I

i

i 1


Página 9

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:

f

NCPINCPIt

***

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.

66 10*10* CPI

f

t

NMIPS

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


Página 10

manera 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.

referencia

evaluando

referencia

lativos MIPSt

tMIPS *Re

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:

6

tan_

10*t

OMFLOPS

teflopunto

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 11

operaciones complejas se puede “normalizar” la diferencia de velocidades permitiendo

comparar de manera más equitativa de dos máquinas.

610*

_*

t

relativopesoOMFLOPS

ii

osnormalizad

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 12

1.2 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 f (MHz) (ns)

Desde 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 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

1.2.2 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 13

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


Página 14

lograda 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 entrada-salida.

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 15

1.3 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


Página 16

acceso (o 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.

1.3.3 Cálculo de la aceleración del rendimiento en la jerarquía de memoria

Registros

Caché

CPU

Caché

Externa

Memoria Principal

Unidades de almacenamiento secundario

May

or C

apac

idad

Meo

r Velo

cidad

de Tran

sferencia

Figura 1.1. Jerarquía de Memoria.


Página 17

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

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:

)1(** hthtt Mcg

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.

Figura 1.2. PC con jerarquización de buses de E/S.

CPU +

Cache L1Cache L2

Controlador

de vídeo

Controladores del sistema

(Chipset)

Controlador de Memoria y

Puente PCI

Memoria

Principal

Controlador IDE

Controlador de DMA

Puente PCI a ISA

SCSI LAN Slot

USBDD

DD

CD

DD

Dispositivos IDE

Slot SlotSuper

I/O

Disquete

Com 1

Com 2 Ratón PS/2

Teclado

LPT

Bus ISA

Bus PCI

Bus del Sistema"Bus" AGP


Página 18

1.4.1 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


Página 19

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.

En computación se ha evidenciado, desde sus inicios, una necesidad y tendencia hacia el

paralelismo:

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.

1.5.1 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.


Página 20

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.

1.5.2.3 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 21

Subsistema de Entrada

/ SalidaMemoria Central

Banco de

Registros

(24 x 32)

Pila de

Instrucciones

Marcador

Lógica

Decremento

Incremento

Suma Fija

División

Multiplic. 2

Multiplic. 1

Suma

Desplazamiento

Bifurcación

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 CDC-

6600 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 22

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 23

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

Ejecución Secuencial(Se ejecuta una instrucción tras otra)

Ejecución Segmentada(Se ejecutan instrucciones solapadamente.

El CPU se organiza en secciones o etapas

que encadenadas se denominan cauce.

Una vez que una instrucción completa su

parte de ejecución en una etapa, pasa a la

siguiente y otra nueva instrucción puede

ocupar la que ésta deja libre. Una vez que el

cauce está lleno, se produce una instrucción

por ciclo)

I1

I2

s1

s5

s4

s3

s2

s1

s5

s4

s3

s2

s1

s5

s4

s3

s2

s1

s5

s4

s3

s2

s1

s5

s4

s3

s2

s1

s5

s4

s3

s2

I1

I2

I3

I4

I6

I5


Página 24

necesarias para 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

S1 S2 S3 S4 S5

Clock

Input Output


Página 25

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.

. . .

. . .

. . .

. . .

S1

S2

S3

S4

1 5432 6 7 8Tiempo

(ciclos)

Espacio

T1

4T

2

4T

3

4T

4

4T

5

4

T1

3T

2

3T

3

3T

4

3T

5

3

T1

2T

2

2T

3

2T

4

2T

5

2

T1

1T

2

1T

3

1T

4

1T

5

1

inst i

inst i+1

inst i+2

inst i+3

inst i+4

Diagrama de Instrucciones Diagrama Espacio/tiempo


Página 26

2.2 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:

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 tk es:

tk = k * + ( N – 1) *

Así la ganancia de rendimiento de un procesador segmentado sobre uno secuencial se define

como:

1

2

3

4

5

r

S1 S2 S3 S4 S5

Clock

Input Output

= Max { i }

k

1+

r =

max +

r

t1 = N * CPI *


Página 27

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

G =N * k

k + ( N -1 )

t1

tk

=

=N * k *

k * *[k + ( N -1 )]

N

k + ( N -1 )=

=N

K + ( N -1 )

= f=


Página 28

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

carga-almacenamiento, 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

(RM).

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 29

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 registro-

registro. 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

Saltos BRx R1, d

; If ( R1 cond 0) then PC = PC +

d

Nota: x puede ser: E ( cond es = ) NE ( cond es # )

LT ( cond es < ) LE ( cond es <= )

GT ( 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,


Página 30

mejoraremos esta arquitectura básica a fin de resolver ciertos problemas de la segmentación

(riesgos estructurales)

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 –

ALU

mdr

pc

mar

ir M

buff

A B

BR

Rd Write

Rf2 RRf1 R

A B

DataBus

@Bus

4


Página 31

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.


Página 32

Instrucción BUS D/L ALU MEM ESC

rd = rf1 op

rf2

OP

mar = pc mdr = M(mar) ir = mdr pc = pc + 4

decodificar A = rf1 B = rf2

buff = A op B

-

rd = buff

rd =

M(rf1+d)

LOAD


decodificar A = rf1 B = d

mar = A + B

mdr = M(mar)

rd = mdr

M(rf1+d) =

rf2

STORE


decodificar A = rf1 B = d mdr = rf2

mar = A + B

M(mar) = mdr

-

if (cond)

pc = pc + d

BRx


decodificar A = pc B = d A’ = rf1

buff = A + B cond = (A’ cmp 0)

if (cond) pc = buff

-

2.6.2 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


Página 33

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.

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.


Página 34

Tabla 2.1. Resumen de Riesgos estructurales con sus soluciones.

Tipo de recurso Riesgos Solución 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 D/L ALU MEM ESC

rd = rf1 op rf2

OP

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

rd = M(rf1+d)

LOAD


decodificar A = rf1 B = d ir2 = ir

mar = A + B ir3 = ir2

mdrin = Md(mar) ir4 = ir3

rd = mdrin

M(rf1+d) = rf2

STORE


decodificar A = rf1 B = d mdr = rf2 ir2 = ir

mar = A + B mdrout = mdr ir3 = ir2

M(mar) = mdrout ir4 = ir3

-

if (cond)

pc = pc + d

BRx


decodificar A = pc B = d A’ = rf1 ir2 = ir

mar = A + B cond = (A’ cmp 0) ir3 = ir2

if (cond) pc = mar ir4 = ir3

-

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 35

2.6.4 DATAPATH DEL DLX

Figura 2.5. Datapath del DLX con dependencias estructurales resueltas

ALU

MDR

PC

MAR

IR

iCache

MDRIN

BR

Rf2 RRf1 R

A B

Inst

@Inst

A'

Comp

0

S4

MDROUT

BR

Rd Write

IR2

IR3

IR4

(offset d)

Cond

DLX Datapath - Dependencias estructurales resueltas

dCache

BUS

D/L

ALU

MEM

ESC

R/W

Reloj

Reloj

Reloj

RelojReloj

Reloj RelojReloj

@datos

datos_out

datos_in

Reloj RelojReloj

R/W

ICache:R/W

BR:@Rf1(CO, R1), Read

BR:@Rf2(CO, R2), Read

MuxA(CO)

MuxB(CO)

ALUsel(CO)

dCache:R/W(CO)

BR:@Rd(CO, Rd|R2)

Señales de ControlSistema de MemoriaReloj


Página 36

2.7 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:

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) ( simplificadamente D-D o RAR)

D(i) R(j) ( simplificadamente D-R o WAR)

R(i) D(j) ( simplificadamente R-D o RAW)

R(i) R(j) ( simplificadamente 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.

EscR1 se escribe aquí

D/L

Necesito el valor de R1 aquí

(i) OP R1, R2, R3

(j) OP R5, R1, R7


Página 37

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.

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.

Valor actualizado de R1

disponible aquí

EscALU

D/L

R1 se escribe aquí

Necesito el

valor de R1

aquí

1ra Latencia

2da Latencia

3ra Latencia

4ta Latencia


Página 38

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:

Los cortocircuitos aplicados son:

OP(i) – OP(i+1) : S(ALU) E(A)|E(B) Es decir, que la salida de la ALU se lleva a la

entrada

del registro A o del registro B (entrad de la ALU) OP(i) - OP(i+2) : 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.

OP(i) - OP(i+3) : 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.


disponible aquí

EscALU

D/L

R1 se escribe aquí


se ocupa aquí

ALU

Cortocircuitos que adelantan

el valor de R1 eliminando las

posibles latencias para

operaciones como OP

Mem

EscALU

D/L

Valor actualizado

requerido aquí

MEM

Valor actualizado

disponible aquí


Página 39

2.7.2.2 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 de 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 los 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 40

2.7.3 RESUMEN DE DEPENDENCIAS DE DATOS EN EL DLX

Instrucciones Involucradas

Escenario Tratamiento

OP - OP OP(i) – OP(i+1) S(ALU) E(A)|E(B)

OP(i) – OP(i+2) S(MAR) E(A)|E(B)

OP(i) – OP(i+3) S(MDRin) E(A)|E(B)

OP - LOAD OP(i) – LOAD(i+1) S(ALU) E(A)

OP(i) – LOAD (i+2) S(MAR) E(A)

OP(i) – LOAD (i+3) S(MDRin) E(A)

OP – STORE CASO 1: OP r1, r2, r3 STORE r5, d(r1)

OP(i) – STORE(i+1)

S(ALU) E(A)

OP(i) – STORE (i+2)

S(MAR) E(A)


S(MDRin) E(A)

OP – STORE CASO 2: OP r1, r2, r3 STORE r1, d(r4)

OP(i) – STORE(i+1)

S(ALU) E(MDR)


S(MAR) E(MDR)


S(MDRin) E(MDR)

LOAD - OP 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 - LOAD LOAD(i) – LOAD(i+1)

Parar el cauce: IR=LOAD y IR2=LOAD y IR2(Rd)=IR(Rf1)

LOAD(i) – LOAD (i+2)

S(Md) E(A)

LOAD(i) – LOAD (i+3)

S(MDRin) E(A)

LOAD – STORE CASO 1: LOAD r1, d(r2) STORE r5, d(r1)

LOAD(i) – STORE(i+1)

Parar el cauce: IR=STORE y IR2=LOAD y IR2(Rd)=IR(Rf1)


S(Md) E(A)


S(MDRin) E(A)


Página 41

LOAD – STORE CASO 2: OP r1, r2, r3 STORE r1, d(r4)


S(Md) E(MDRout)


S(MDRin) E(MDRout)


S(MDRin) E(mdr)

STORE - Cualquiera

NO HAY

OP – BRx BRx va a cambiar (Con la solución de riesgos de control)

LOAD – BRx

BRx - Cualquiera NO HAY


Página 42

2.7.4 DATAPATH DEL DLX CON DEPENDENCIAS DE DATOS RESUELTAS

Figura 2.6. Datapath del DLX con dependencias de datos resueltas

ALU

MDR

PC

MAR

IR

iCache

MDRIN

BR

Rf2 RRf1 R

A B

Inst

@Inst

A'

Comp

0

S4

MDROUT

BR

Rd Write

IR2

IR3

IR4

(offset d)

Cond

DLX Datapath - Dependencias de datos resueltas

dCache

BUS

D/L

ALU

MEM

ESC

R/W

Reloj

Reloj

Reloj

RelojReloj

Reloj Reloj Reloj

@datos

datos_out

datos_in

Reloj RelojReloj

R/W

ICache:R/W

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)

ALUsel(IR2)

Comp(IR2)

MuxMDRout(IR2, IR3)

dCache:R/W(IR3)

MuxPC(IR3,Cond)

MuxMDRin(IR3)

BR:@Rd(IR4), Write

Señales de ControlSistema de Memoria

Reloj

(a, b, c)(a, b, c) (a, b, c) NOP

(a)

(b)

(c)

(b)

Ld_PC

Ld_IR

Nota: Los cambios respecto al DataPath con Dep. Estructurales resueltas se muestran en azul fuerte


Página 43

2.8 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) pc = pc +

d

BRx



mar = A + B cond = (A’ cmp 0)

if (cond) pc = mar

-

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.

ALUBRxi

k

PC

MEMBRx i

k

PC


Página 44

Según el ejemplo anterior, el ciclo de máquina real, con el adelantamiento es:

r = 0.2( + 2) + 0.8 1.4

if (cond) pc = pc +

d

BRx



mar = A + B if = (A’ cmp 0) pc = A + B

-

-

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?

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) pc = pc +

d

BRx


decodificar if = (Rf1 cmp 0) pc = pc + d

-

-

-

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.

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

D/LBRxi

k

PC


Página 45

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 ciclo, IR2 = BRx e IR=NOP.

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

Escenario Tratamiento

OP - BRx OP(i) – BRx(i+1) 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 - BRx LOAD(i) – BRx(i+1) Parar el cauce: IR=BRx y IR2=LOAD y IR2(Rd)= IR(Rf1)

LOAD(i) – BRx (i+2)

S(Md) E(Cmp) Debe estudiarse si queda tiempo para que se dé, caso contrario, parar.

LOAD(i) – BRx (i+3)

S(MDRin) E(Cmp)

D/LBRx i

k

PC

i+1

If (Rf1 cmp 0) : PC = @Salto

else: PC = PC + 4

PC

IR

iCache

Inst

@Inst

S4

R/W

Reloj

@Salto

NOP


Página 46

2.8.3 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 47

Ejemplo:

Continuación Salto

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

…

1) MUL R1, R2, R9

2) ADD R7, R1, R9

3) DIV R7, R1, R9

4) SUB R4, R4, R6

5) BRx R4, d (i)

Bloque básico

6) MUL R5, R13, R13 (i+1)

7) SUB R15, R7, R8

8) SUB R12, R5, R6

…

9) SUB R12, R7, R1 (k)

10) ADD R13, R12, R5

11) ADD R6, R5, R6

…


Página 48

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 49

2.8.4 DATAPATH DEL DLX CON LAS DEPENDENCIAS DE CONTROL RESUELTAS

Figura 2.8. Datapath del DLX con las dependencias de control resueltas

ALU

MDR

PC

MAR

IR

iCache

MDRIN

BR

Rf2 RRf1 R

A B

Inst

@Inst

Comp

0

S4

MDROUT

BR

Rd Write

IR2

IR3

IR4

(offset d)

DLX Datapath - Dependencias de datos resueltas

dCache

BUS

D/L

ALU

MEM

ESC

R/W

Reloj

Reloj

Reloj

RelojReloj

Reloj Reloj

@datos

datos_out

datos_in

RelojReloj

R/W

ICache:R/W

BR:@Rf1(IR), Read

BR:@Rf2(IR), Read

Cmp(IR); S@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)

ALUsel(IR2)

MuxMDRout(IR2, IR3)

dCache:R/W(IR3)

MuxMDRin(IR3)

BR:@Rd(IR4), Write

Señales de ControlSistema de Memoria

Reloj

(a, b, c)

(a, b, c)

(a, b, c) NOP

(a)

(b)

(c)

(b)

Ld_PC

Ld_IR

S

@salto

NOP

Nota: Los cambios respecto al DataPath con Dep. de Datos resueltas se muestran en azul fuerte

@Salto

PC d

@Salto

PC + 4

Cond


Página 50

2.9 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 51

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 52

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

Figura 2.10. Diagrama a bloques de un segmentado lineal.

Figura 2.11. Diagrama a bloques de un segmentado no-lineal.

T1

T2

T3

T4

T1 T3T2 T4

out

in

1 2 3in out

Grafo de Precedencia Lineal Grafo de Precedencia No lineal

13

2 4

S1 S2 S3 S4 S5

S1 S2 S3 S4 S5


Página 53

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

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.

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.

BUS D/L MEM ESC

ALU

E

MUL

E/PF

SUM

PF

DIV

E/PF


Página 54

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

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 2 3 4 5 6 7 8

1 X X

2 X X X

3 X

4 X X

5 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


Página 55

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

0 0 1 0 1 1 0 0 (OR) 1 0 1 1 0 0 0 1

1 0 1 1 1 1 0 1 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.

0 0 0 1 0 1 1 0 0 0 0 0 1 0 1 1 (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)


Página 56

Luego, tomamos el estado 2 y aplicamos desplazamiento 2 generando el estado 5. El desplazamiento 7 retorna al estado 1:

0 0 1 0 1 1 1 1 0 0 0 0 0 0 0 1 (OR) 1 0 1 1 0 0 0 1 (OR) 1 0 1 1 0 0 0 1

1 0 1 1 1 1 1 1 Estado 5 1 0 1 1 0 0 0 1 Estado 1 ( 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.

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 Latencia media Avaricioso

( 7 ) 7

( 3, 7 ) 5

( 3, 4 ) 3.5 SI, tiene la mlm

( 4, 3, 7 ) 4.6

( 4, 7 ) 5.5

( 2, 7 ) 4.5

( 2, 2, 7 ) 3.6 SI

( 3, 4, 7 ) 4.6

10110001

10110111 10111101

10111011 10111111

7+

37+

7+

7+

7+

4 2

243

1

23

54


Página 57

3 ARQUITECTURAS SIMD

3.1 INTRODUCCIÓN

3.1.1 Necesidad de procesamiento de Vectores y matrices:

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

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, j-

1]).

FOR I = 1 TO N

FOR J=1 TO M

C [I, J] = 0.0

FOR K=1 TO L

C [I, J] =

C[I,J]+A[I,K]*B[K,J]

END FOR

END FOR

ENDFOR


Página 58

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)

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 59

3.2.2 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 60

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.

3.3.3 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:

E

n

mascaramiento y vectores binarios.

Usualmente tienen múltiples Cauces vectoriales (Unidades funcionales) y Escalares.

COP V1 V2 Vr Incr Tam

COP RV1 RV2 RVr Tam

COP RV1 Tam@V2 Incr


Página 61

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.

MEMORIA

PRINCIPAL

UNIDAD DE

PROCESAMIENTO DE

INSTRUCCIONES

(IPU)

CONTROLADOR DE

ACCESO VECTORIAL

CONTROLADOR DE

INSTRUCCIONES

VECTORIALES

BANCO DE

REGISTROS

ESCALARES

BANCO DE

REGISTROS

VECTORIALES

Procesador

Escalar

Procesador

Vectorial

CAUCE 1

CAUCE 2

CAUCE n

CAUCE V1

CAUCE V2

CAUCE Vn


Página 62

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 Procesadores Sistólicos

3.5.1 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 63

3.5.2 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

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.

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

MEMORIA

P

MEMORIA

EP EPEPEP

Procesador convencional Matriz Sistólica

EP

EP

EP

EP

EP

EP

EP

EP

EP

EP

EP

EP

EP

EP

EP

EP EP EP

EP

EP EP

EP EP EP EP

Matriz Cuadrada Matriz Hexagonal Arbol sistólico

W2

W1

W0

0 0 0

X0

2 1 0

W

X

YZ = W * X + Y

Fig 1: Celda EP del procesador

sistolico

Fig 2: Estructura de Interconexion del

Procesador sistolico


Página 64

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

0

0

0

0

A12

A11

A22

A21

B21

B11

B22

B12


Página 65

3.8 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 66

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)


Página 67

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

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:

4.1 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.

P

Pr

Pr

Pr

Pr

P1

P2

P3

Pr

Pr

Pr

Pr

Sistema

Monoprocesador

Sistema

Multiprocesador


Página 68

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.

4.2.1 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. 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 por el bus. Una

medida paliativa muy eficaz

consiste en definir una jerarquía de

memoria de al menos dos niveles.

Muchos MP de 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.

P1

P2

P3

P4

M1

M2

IOP IOP

MIMD con Estructura de interconexión

empleando Bus común


Página 69

4.2.2 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.

P1

P2

P3

P4

IOP

IOP

M1

M2

MIMD con Estructura de interconexión

mediante Memorias Multipuerto


Página 70

4.2.4 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.

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

0

1


Página 71

algoritmos de enrutamiento de paquetes o mensajes. La figura abajo muestra la construcción

escalable de hipercubos de 1 a 4 dimensiones.

4.3 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.

Otras estructuras de interconexión tienen sus propios esquemas (revisar barra-cruz, red

multietapa, etc)


Página 72

4.3.2 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:

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.

4.4 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:


Página 73

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.

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.

Download - Folle to 2014

Top Related