IC2 Resumen

lOMoARcPSD|215678
Temas 1-4: Procesadores
Ingeniería de Computadores II (UNED)
Su distribución está prohibida | Descargado por Daniel Bar (danbbt@hotmail.com)

lOMoARcPSD|215678
Procesadores segmentados
1. PROCESADORES SEGMENTADOS .........................................................2
1.2. Introducción ........................................................................................................................................ 2
1.3. Procesadores RISC frente a procesadores CISC ............................................................................ 2
1.4. Clasificación de las arquitecturas paralelas .................................................................................... 2
1.5. Evaluación y mejora del rendimiento de un computador .............................................................. 6
1.6. Características de los procesadores segmentados ....................................................................... 9
1.7. Arquitectura segmentada genérica (ASG) ..................................................................................... 10
1.7.1. Repertorio de instrucciones de la ASG ...................................................................................... 10
1.7.1.1. Aritméticas y lógicas ........................................................................................................... 11
1.7.1.2. Transferencia de datos ....................................................................................................... 11
1.7.1.3. Bifurcaciones y saltos incondicionales. Saltos condicionales. ........................................... 12
1.7.2. Implementación de la segmentación de instrucciones en la ASG ............................................. 12
1.8. Riesgos en la segmentación ........................................................................................................... 14
1.8.1. Riesgos estructurales ................................................................................................................. 15
1.8.2. Riesgos por dependencias de datos .......................................................................................... 16
1.8.2.1. La reorganización de código............................................................................................... 16
1.8.2.2. El interbloqueo entre etapas ............................................................................................... 18
1.8.2.3. El adelantamiento (caminos de bypass oforwarding) ......................................................... 18
1.8.3. Riesgos de control ...................................................................................................................... 19
1.9. Planificación dinámica: Algoritmo de Tomasulo .......................................................................... 22
Página 1

lOMoARcPSD|215678
1. PROCESADORES SEGMENTADOS
1.2. Introducción
Un procesador segmentado es capaz de procesar varias instrucciones simultáneamente, aunque cada una de ellas
puede encontrarse en una etapa distinta de su procesamiento.
 Dos etapas del RISC I (1982),

 Las 10 etapas del Pentium III.
 Las 20 ó 31 etapas del Pentium 4 (2000-2005) según modelo.
 Hasta las 14 etapas de los procesadores basados en la microarquitectura Intel Core (2006-2010).
1.3. Procesadores RISC frente a procesadores CISC
Década de los años 70, debido al alto coste por byte los computadores no disponían, en general, de grandes
cantidades de memoria, se desarrollaron computadores con instrucciones complejas que permitieran realizar
operaciones con código reducido CISC.
(Complex Instruction Set Computer - Computadores con Conjunto de Instrucciones Complejo).
La arquitectura tipo CISC dificultaba el paralelismo a nivel de instrucciones.
Buscando aumentar la velocidad del procesamiento, se descubrió la ejecución de programas compilados con
instrucciones simples (de complejidades similares a las microinstrucciones de los procesadores CISC) resultaban
ser más eficientes.
Debido a que un procesador RISC tiene un conjunto de instrucciones simplificado no es necesario disponer de un
hardware de control extremadamente complejo. Propone un conjunto de instrucciones sencillas con formatos fijos
permitiendo ejecución segmentada de las instrucciones (pipeline).
Reduce el tamaño de la CPU, dispone de más espacio para más recursos, por ejemplo, mayor
cantidad de registros o de memoria caché.
Ventajas de Al ser la lógica de control más simple, se facilita el diseño.

un diseño Permite máquinas más compactas y con menor consumo al reducirse el tamaño de la CPU.
RISC
Posibilita la segmentación y el paralelismo en la ejecución de instrucciones.
Reduce los accesos a memoria debido a que los operandos se cargan en registros.
Para minimizar los riesgos, la arquitectura RISC plantea en su filosofía de diseño una relación muy estrecha entre
los compiladores y la propia arquitectura.
1.4. Clasificación de las arquitecturas paralelas
La contribución Replicación de elementos: Unidades

de la arquitectura funcionales, procesadores, módulos de
Paralelismo memoria, etc.
al aumento de las
prestaciones de Segmentación de cauce (segmentación)
los computadores (pipelining)
ha venido dada Localidad espacial y
por: temporal
Página 2

lOMoARcPSD|215678
SISD
SI -- Single Instruction
Clasificación de SIMD SD -- Single Data
los tipos de
MIMD MI -- Multiple Instruction
computadores
MD -- Multiple Data
MISD
Página 3

lOMoARcPSD|215678
EJEMPLO
 Un SISD necesita 12 Intervalos.

 SIMD
Necesita tres intervalos de tiempo.
 MIMD
Necesita cuatro intervalos de tiempo.
- De datos. Una misma función sobre datos diferentes.

Tipos de paralelismo Las funciones, bloques, instrucciones, se
- Funcional.
ejecutan en paralelo.
En paralelo instrucciones.
- Nivel de instrucciones u operaciones Ganularidad fina. (Cantidad de trabajo asociado a
(ILP, Instruction Level Parallelism) cada tipo de tarea candidata a la paralelización)
En paralelo distintas iteraciones de un bucle o
Paralelismo - Nivel de bucle. secuencias de instrucciones de programa.
funcional Ganularidad fina-media.
Los distintos procedimientos se ejecutan
- Nivel de funciones. simultáneamente. Ganularidad media.
Programas ejecutados en paralelo. Ganularidad
- Nivel de programas gruesa.
Página 4

lOMoARcPSD|215678
ALTERNATIVAS A PARA AUMENTAR LAS PRESTACIONES DE LOS PROCESADORES
Página 5

lOMoARcPSD|215678
1.5. Evaluación y mejora del rendimiento de un computador
• Tiempo de respuesta: Tiempo que tarda el computador en procesar una entrada

(programa, instrucción, etc.)
• Productividad (throughput): Número de entradas procesadas por unidad de tiempo.
Medidas para • Funcionalidad: Tipos de entradas diferentes que es capaz de procesar.

evaluar el
rendimiento • Expansibilidad: Posibilidad de ampliar la capacidad de procesamiento añadiendo bloques
a la arquitectura existente.
• Escalabilidad: Posibilidad de ampliar el sistema sin que esto suponga una devaluación de
las prestaciones.
• Eficiencia: Relación entre el rendimiento obtenido y el coste que ha supuesto conseguirlo
(eficiencia = rendimiento/ coste).
Ejemplos
Entradas Accesos de memoria Entradas Programas
Latencia de memoria. Tiempo de
MEMORIA COMPUTADOR
Rendimiento Ancho de banda. Rendimiento respuesta.
Escalabilidad. Productividad.
Entradas Instrucciones
CPIi
PROCESADOR
Rendimiento CPI (medio)
Frecuencia de reloj
MODELOS
TCPU= Tiempo de CPU de un program. o

tarea
NI= Nº instrucciones
CPI= Nº medio de ciclos por instrucción
Tciclo= periodo de reloj del procesador = 1/f
CPIi= Nº medio de ciclos por instrucción de

tipo i.
NIi= Nº instrucciones de ese tipo
PARALELISMO CPE= Nº medio de ciclos entre inicios de

ejecución de instrucciones.
IPE= Nº medio de instruc. que se emiten
Noperaciones= Nº operaciones que realiza el

programa.
OPinstrucción= Nº medio de operaciones que
puede codificar una instrucc.
Página 6

lOMoARcPSD|215678
Ejemplos de valores característicos de CPE , IPE y CPI según las microarguitecturas
segmentadas, superescalares y VLIW.
Medida que puede variar con el programa

Solo mide la velocidad de ejecución de las
instr., no es medida real de
rendimiento.
No es medida adecuada para todos los

programas.
p = rendimiento con la mejora
Sp (speedup)
Página 7

lOMoARcPSD|215678
LEY DE AMDAHL
p=Rendimiento con la mejora

f = fracción de tiempo de ejecución en la
máquina original en la que no se puede
aplicar la mejora.
Ejemplo
Si una máquina pasa un 25% de su tiempo procesando instrucciones de coma flotante y se mejora la máquina
haciendo que esas instrucciones se ejecuten en la mitad de tiempo, esto es p = 2, entonces la ganancia que se
puede obtener es
Es decir, la máquina mejorada solo es un 14% mejor.
Por mucho que se mejore el recurso, la ganancia será siempre limitada por 1/f
Ejemplo
Se desea mejorar el rendimiento de un computador introduciendo un coprocesador matemático que realice las
operaciones aritméticas en la mitad de tiempo. ¿Cuál sería la ganancia en velocidad del sistema para la
ejecución de un programa si el 60% del mismo se dedicase a operaciones aritméticas? Si el programa tarda 12
segundos en ejecutarse sin la mejora, ¿Cuánto tardará con la mejora?
Ganancia:
p=2
f= fracción de tiempo sin mejora. Mejora el 60% del tiempo  1-0.6= 0.4 sin mejora
Tiempo con la mejora:
12
8,45
1,42
Página 8

lOMoARcPSD|215678
1.6. Características de los procesadores segmentados
Procesador no segmentado
Procesador segmentado
Para que el tiempo de latencia del procesador segmentado sea el mínimo posible, es necesario que el procesador
esté equilibrado, es decir, que todas las subtareas en que se haya dividido la tarea total tarden en procesarse el
mismo tiempo.
La relación de precedencia de un conjunto de subtareas T1, …. , T17 que componen cierta tarea T, específica
para cada subtarea Tj que no puede comenzarse hasta que hayan terminado ciertas subtareas Ti.
Las relaciones de precedencia para todas las subtareas de T forman su grafo de precedencia. En el ejemplo de la
Figura se ha supuesto que las tareas que se procesan en el cauce tienen un grafo de precedencia lineal. Esto
significa que una subtarea Tj no puede comenzar hasta que todas las subtareas previas, es decir Ti, i < j , hayan
finalizado. A los procesadores segmentados que solo pueden procesar tareas con grafo de precedencia de este
tipo se les denomina de cauce lineal.
Página 9

lOMoARcPSD|215678
1.7. Arquitectura segmentada genérica (ASG)
Existen dos características importantes de los repertorios de instrucciones que permiten clasificar las arquitecturas
de propósito general:
 El número de operandos que pueden tener las instrucciones aritmético-lógicas.

 El número de operandos que se pueden direccionar en memoria en las instrucciones aritmético-lógicas.
Las instrucciones aritmético-lógicas de la ASG utilizan en total tres operandos y ninguno de ellos se
referencia en memoria. A las máquinas en las que los operandos no se referencian en memoria se les denomina
máquinas registro-registro o máquinas de carga/almacenamiento.
1.7.1. Repertorio de instrucciones de la ASG
Registros
Registros 32 de 32 bits R0 .. R31 R0 = 0
genéricos
de la 32 de simple precisión, 32 bits F0 .. F31
Reg. Coma
ASG
flotante 16 parejas de 64 bits F0, F2, F4, .. F30
Aritméticas y lógicas
Tipos básicos de Transferencia de datos
instrucciones Bifurcaciones y saltos incondicionales
Saltos condicionales
Página 10

lOMoARcPSD|215678
1.7.1.1. Aritméticas y lógicas
1.7.1.2. Transferencia de datos
Página 11

lOMoARcPSD|215678
1.7.1.3. Bifurcaciones y saltos incondicionales. Saltos condicionales.
1.7.2. Implementación de la segmentación de instrucciones en la ASG
1. IF (lnstruction Fetch): Lectura de la instrucción de la caché de instrucciones.

2. ID (lnstruction Decoding): Decodificación de la instrucción y lectura de sus operandos
del fichero de registros.
3. EX (Execution): Ejecución de las operaciones si se trata de una instrucción aritmético-
Etapas básicas lógica y del cálculo de la condición y de la dirección de salto si se trata de una
bifurcación o salto condicional.
4. MEM (Memory access): Acceso a la caché de datos para lecturas (cargas) o
escrituras (almacenamientos).
5. WB (Write-Back results) : Escritura del resultado en el fichero de registros.
Página 12

lOMoARcPSD|215678
Organización lógica de la segmentación de instrucciones de la ASG de cinco etapas.
Página 13

lOMoARcPSD|215678
El tiempo total de ejecución de la instrucción segmentada es ligeramente superior al de su equivalente no
segmentada debido al tiempo que se consume en el control de la segmentación.
 Los cerrojos o buffers de contención

Factores que
determinan el  La duración de todas las etapas de la segmentación es similar y viene
tiempo de ejecución determinada por la duración de la etapa más lenta.
de las instrucciones  Los riesgos que se producen en la segmentación y que introducen detenciones
en el cauce.
1.8. Riesgos en la segmentación
Riesgo: a la situación que impide a una instrucción acceder a la ejecución de sus etapas al depender de otra
anterior.
 Riesgos estructurales: Surgen de conflictos por los recursos, es decir, por insuficiencia del
hardware.
 Riesgos por dependencia de datos: Surgen cuando una instrucción necesita los resultados de
Riesgos
otra anterior.
 Riesgos de control: Se originan a partir de las instrucciones de control de flujo (saltos y
bifurcaciones).
Página 14

lOMoARcPSD|215678
1.8.1. Riesgos estructurales

Surgen de conflictos por los recursos, es decir, por insuficiencia del hardware.
La ASG no se presenta este inconveniente porque se dispone de dos memorias caché, una para
instrucciones (I-caché) y otra para datos (D-caché).
Otras
 No todas las etapas de la segmentación tienen la misma duración.
situaciones
de riesgos
estructurales  Hay instrucciones más complejas que otras
SOLUCIONES
DUPLICAR LA UNIDAD FUNCIONAL PLANIFICACIÓN DE CÓDIGO
Página 15

lOMoARcPSD|215678
1.8.2. Riesgos por dependencias de datos

Cuando dos instrucciones comparten algún dato
Ejemplo instrucción i se ejecuta antes que la j

 Riesgo de tipo RAW (ReadAfter Write- Lectura Tras Escritura):
instrucción j intenta leer un dato antes de que la instrucción i lo
Clasificación escriba
de los  Riesgo de tipo WAR (Write After Read- Escritura Tras Lectura),
riesgos por (antidependencia) : instrucción j trata de escribir en su destino antes
dependencia que éste sea leído por la instrucción i
Dependencias falsas
de datos  Riesgo de tipo WAW (Write After Write - Escritura Tras Escritura)
(dependencia de salida): instrucción j intenta escribir un operando
antes de que éste sea escrito por la instrucción i.
Para ASG solo existe el riesgo RAW
 La reorganización de código.
Métodos
evitar
 El interbloqueo entre etapas.
riesgos
RAW
 El adelantamiento.
1.8.2.1. La reorganización de código

CUANDO EL COMPILADOR RETRASA LA 2ª INST. RESPECTO DE LA 1ª
1. AL NO REORGANIZAR CÓDIGO  UNA DETENCIÓN (BURBUJA) DE 4 CICLOS

2. EL COMPILADOR INSERTA INSTRUCCIONES NOP
Página 16

lOMoARcPSD|215678
Procesado
ores segmenntados
IMPLICA UN CO
OMPILADO
OR MÁS COMPLEJO
O
Página 17

lOMoARcPSD|215678
1.8.2.2. El interbloqueo entre etapas
Introducir elementos hardware en el cauce para detectar la existencia de dependencias
1.8.2.3. El adelantamiento (caminos de bypass o forwarding)

Uso de los elementos que en la técnica de interbloqueo permiten detectar la existencia de dependencias entre
instrucciones. Esta información ahora se aprovecha para habilitar una serie de caminos (buses) que se añaden al
cauce para permitir que los resultados de una etapa pasen como entradas a la etapa donde son necesarios en
caso de dependencias RAW, al mismo tiempo que siguen su camino para almacenarse en el fichero de registros.
Detecta si hace falta algún

resultado que se ha de dejar en un
registro para la siguiente
instrucción. En caso afirmativo, lo
guarda en el registro, pero se lo
suministra directamente a la ALU
Página 18

lOMoARcPSD|215678
1.8.3. Riesgos de control

Un salto condicional, el valor del contador del programa puede incrementarse automáticamente o cambiar
su valor en función de que el salto sea efectivo o no efectivo. En la ASG la instrucción i es un salto efectivo
entonces el PC no se actualiza hasta el final de la etapa MEM de la segmentación.
Página 19

lOMoARcPSD|215678
etiqueta
BEQZ R7,etiqueta
BEQZ
R7
Página 20

lOMoARcPSD|215678
Técnica del salto retardado
Otra alternativa sería dejar que las instrucciones que se han captado prosigan su ejecución en el cauce.
En este caso, el compilador debería introducir en esos huecos instrucciones que se tengan que ejecutar antes
de la instrucción destino de salto de forma que su efecto sea independiente de que el salto sea efectivo o no.
ORIGINAL
i1, i2 e i3 no influyen para el salto, por lo tanto se pueden cambiar de posición. Mientras se codifica y
ejecuta el salto (i4) se van ejecutando las i1, i2 e i3
Técnica de predecir el salto como no efectivo
Técnica de adelanto del cálculo de la dirección (por predicción)
Página 21

lOMoARcPSD|215678
1.9. Planificación dinámica: Algoritmo de Tomasulo
Planificación estática: limitación de las técnicas de segmentación estática es que emiten las instrucciones en
orden.
Planificación dinámica: en la que el hardware reorganiza la ejecución de la instrucción para reducir las
detenciones mientras mantiene el flujo de datos y la consistencia del estado del procesador y de la
memoria.
Mediante la planificación dinámica se comprueban los riesgos estructurales cuando se decodifica la
instrucción. Este hecho conlleva que todavía se mantiene el orden del programa, pero las
instrucciones comienzan a ejecutarse tan pronto como todos sus operandos están disponibles. De
esta manera, el procesador segmentado realizaría ejecución de instrucciones fuera de orden, lo
que implica terminación fuera de orden.
La planificación dinámica tiene sentido cuando hay múltiples unidades funcionales y por eso
hay que diferenciar entre distribuir las instrucciones hacia las unidades funcionales y comenzar su
ejecución.
Es preciso desdoblar la etapa ID en dos fases:
 Decodificación (ID, Instruction Decoding): Decodificación de instrucciones y comprobación de los

riesgos estructurales.
 Emisión (II, lnstruction lssue): La instrucción espera hasta que no haya riesgos de tipo RAW y
cuando estén listos todos los operandos fuente, se leen y se emite la instrucción hacia la unidad
funcional.
Ejemplo de la ejecución de un fragmento de código sin planificación y con planificación

dinámica.
Latencia de unidad de multiplicación, 5 ciclos.
Latencia de unidad de suma, 2 ciclos.
Figura 1.38: Diseño modificado de la unidad de coma flotante del IBM 360/91 con el algoritmo de Tomasulo.
Página 22

lOMoARcPSD|215678
Dos unidades funcionales:

 Suma de coma flotante.
 Multiplicación/división de coma flotante.
Los buffers de coma flotante (FB). Los datos de memoria se cargan en uno de los 6 registros FB.
Los buffers de almacenamiento de datos (SDB). El resultado a almacenar se coloca en uno de los 3
registros SDB. Una unidad independiente accede a los SDB para terminar el almacenamiento del
resultado en la ubicación de memoria correspondiente.
Mediante estos dos ficheros de registros adicionales FB y SDB, la FPU admite instrucciones de
almacenamiento-registro y registro-almacenamiento, funcionando como una máquina registro a registro.
Cola de operaciones de coma flotante FLOS (Floating Point Operation Stack).

Estaciones de reserva (RS, Reservation Stations).
La unidad de instrucción decodifica todas las instrucciones y pasa en orden a la cola de operaciones de
coma flotante FLOS (Floating Point Operation Stack). A continuación, ya en la FPU, las instrucciones se
emiten en orden desde la FLOS a las dos unidades funcionales.
Página 23

lOMoARcPSD|215678
El uso de estaciones de reserva y del fichero de registros centralizado FR da lugar a dos propiedades:
 La detección de riesgos y el control de la ejecución están distribuidos ya que la información mantenida en

las estaciones de reserva de cada unidad funcional determina si una instrucción puede empezar su
ejecución en esa unidad.
 Los resultados pueden pasar directamente a la unidad funcional desde las estaciones de reserva donde
estaban almacenados, en vez de acceder a ellos a través de los registros. Para realizar este
adelantamiento se utiliza un bus de datos común (CDB, Common Data Bus).
Cuando la FLOS envía una instrucción a una unidad funcional, la asigna una estación de
reserva y comprueba si están disponibles los operandos necesarios. Si un operando se
encuentra disponible en el FR, el contenido de ese registro del FR se copia a la estación
de reserva; en caso contrario, se copia una etiqueta para indicar que esa instrucción está
a la espera de un operando pendiente de ser generado. La etiqueta indica de dónde
procederá el operando pendiente, pudiendo ser de una instrucción que está actualmente
en una de las cinco estaciones de reserva o de uno de los seis registros de FLB.
Cada estación de reserva contiene dos campos por operando, donde uno corresponde a la etiqueta y otro al valor
del operando. Los cuatro FR y los tres registros del SDB también llevan un campo etiqueta asociado. En las
estaciones de reserva si un campo de operando contiene datos reales, entonces su campo de etiqueta se
establece a cero. En caso contrario, su campo de etiqueta identifica el origen del que procede el operando
pendiente.
Al mismo tiempo, se establece a 1 el bit de ocupado asociado con el registro destino del resultado en el FR, lo que
indica que existe una actualización pendiente de ese registro, y el valor de la etiqueta que identifica la estación de
reserva a la que se distribuye la instrucción se escribe en el campo de etiqueta del FR correspondiente.
Ejemplo de ejecución de un código

Hipótesis:
 Para reducir el número de ciclos máquina se permite que la FLOS distribuya hasta dos instrucciones en
cada ciclo según el orden del programa.
 Una instrucción puede comenzar su ejecución en el mismo ciclo en que se distribuye a una estación
de reserva.
 La operación suma tiene una latencia de dos ciclos y la de multiplicación de tres ciclos.
 Se permite que una instrucción reenvíe su resultado a instrucciones dependientes durante su último
ciclo de ejecución. De esta forma, una instrucción a la espera de un resultado puede comenzar su
ejecución en el siguiente ciclo si detecta una coincidencia.
 Los valores de etiqueta 01 , 02 , 03 se utilizan para identificar las tres estaciones de reserva de la
unidad funcional de suma, mientras que 04 y 05 se utilizan para identificar las dos estaciones de reserva
de la unidad funcional de multiplicación/división. Estos valores de etiqueta son los ID de las estaciones
de reserva.
 Inicialmente, el valor de los registros es F0=6.0, F2=3.5, F4=10.0 y F6=7.8.
Página 24

lOMoARcPSD|215678
Página 25

lOMoARcPSD|215678
Página 26

lOMoARcPSD|215678
Ciclo 1:
1. Se distribuyen i1 e i2 a RS01 (suma) y RS04 (mul/div).
2. Los registros destino son F4 y F2. Los bits de ocupado FR se activan.
3. Como i1 a RS01 (1º libre de RS suma)  etiqueta de FR =01 a F4. (Indica de qué RS se obtendrá)
4. Como i2 a RS02 (1º libre de RS mul/div)  etiqueta de FR =04 a F2. (Indica de qué RS se obtendrá)
5. i1: ADDD F4, F0, F6  Como están disponibles F0 y F6 sus etiquetas de los operandos de RS01 se
ponen a 0.
6. Comienza la ejecución de i1.
7. I2: MULTD F2, F0, F4  i2 necesita F4 que viene de i1. Por lo tanto la etiqueta de RS04 = 01 (De la
RS01 donde está i1)
Ciclo 2:
1. i3: ADDD F4, F4, F6
2. i4: MULTD F6, F4, F2
3. Se distribuyen i3 e i4 a RS02 (suma) y RS05 (mul/div).
4. Para i3 se necesita el resultado de i1 (F4). En RS02 se pone etiqueta a 01 (Indica que depende de RS01).
5. Para i4 se necesita el resultado de i2 (F2) e i3 (F4). En RS05 pone etiquetas 02 y 04 (Indica que depende
de RS02 y RS04).
6. Como el destino de i3 es F4, se actualiza la etiqueta de FR de 01 a 02. Indica que RS02 deberá actualizar
el valorde F4. Bit de ocupado sigue activo.
7. Cuando i4 se distribuye a RS05, el bit de ocupado de FR se activa y su etiqueta (FR) se pone a 05 (Indica
que es RS05 el que debe actualizar le valor de F6.
8. Termina i1, emite su ID (RS01) y su resultado a CDB. Todos los campos con etiqueta = 01 se actualizan al
valor de F4. Actualizando RS02 (i3) con valor de operando a 13,8 y etiqueta a 00. Actualizando RS04 (i2)
con valor de operando a 13,8 y etiqueta a 00.
Ciclo 3:
1. Comienza a ejecutarse i3 e i2 en unidad de suma y unidad de mul/div.
2. Se libera RS01.
Ciclo 4:
1. Finaliza i3 y emite resultado a CDB y la etiqueta 02.
2. Como RS05 tiene etiqueta 02  se pone el resultado de la suma (21,6) y el valor de su etiqueta (RS05) se pone a
00.
3. Se libera RS02.
Ciclo 5:
1. Finaliza i2 y emite resultado a CDB y la etiqueta 04.
2. Como RS05 tiene etiqueta 04  se pone el resultado de la multiplicación (82,8) y el valor de su etiqueta (RS05) se
pone a 00.
3. Se libera RS04.
Ciclo 6:
1. Comienza ejecución de i4 y acaba en el ciclo 8.
Página 27

lOMoARcPSD|215678
Procesadores VLIW y Procesadores vectoriales

3. PROCESADORES VLIW Y PROCESADORES VECTORIALES ...............2
3.2. Introducción ........................................................................................................................................ 2
3.3. El concepto arquitectónico VLIW ..................................................................................................... 2
3.4. Arquitectura de un procesador VLIW genérico ............................................................................... 2
3.5. Planificación estática o basada en el compilador ........................................................................... 3
3.6. Desenrollamiento de bucles .............................................................................................................. 6
3.7. Segmentación software ..................................................................................................................... 8
3.8. Planificación de trazas (trace scheduling) ....................................................................................... 9
3.9. Operaciones con predicado ............................................................................................................ 12
3.10. Tratamiento de excepciones ........................................................................................................... 13
3.11. El enfoque EPIC ................................................................................................................................ 13
3.12. Procesadores vectoriales ................................................................................................................ 15
3.13. Arquitectura vectorial básica .......................................................................................................... 15
3.14. Repertorio genérico de instrucciones vectoriales ........................................................................ 17
3.15. Medida del rendimiento de un fragmento de código vectorial .................................................... 18
3.15.1.1. Rendimiento de un procesador vectorial en FLOPs por ciclo ............................................ 19
3.16. La unidad funcional de carga/almacenamiento vectorial............................................................. 20
3.17. Medida del rendimiento de un bucle vectorizado ......................................................................... 22
3.17.1. Caso 1: Sin encadenamiento de resultados entre unidades ...................................................... 24
3.17.2. Caso 2: Con encadenamiento de resultados entre unidades .................................................... 25
3.17.3. Caso 3: Con encadenamiento y dos unidades de carga/almacenamiento ................................ 26
3.17.4. Caso 4: Con encadenamiento, dos unidades de carga/almacenamiento y solapamiento entre
convoyes dentro de la misma iteración ..................................................................................................... 27
Página 1

lOMoARcPSD|215678
3. PROCESADORES VLIW Y PROCESADORES VECTORIALES

3.2. Introducción
El paralelismo funcional se obtiene mediante la replicación de las funciones de procesamiento que realiza el
computador.
• Granularidad fina → a nivel de instrucciones
• Granularidad gruesa → a nivel de programas
VLIW (Very Long Instruction Word - Palabra de Instrucción Muy Larga)

Un procesador VLIW se caracteriza por emitir en cada ciclo de reloj una única instrucción pero que contiene varias
operaciones o mini-instrucciones tipo RISC.
• Ejecutar en paralelo es responsabilidad exclusiva del compilador.
3.3. El concepto arquitectónico VLIW

El hardware no tiene que intervenir para descubrir el paralelismo entre instrucciones, ya que es responsabilidad
exclusiva del compilador el generar un código binario formado por instrucciones que comporten operaciones
paralelas.
Planificación estática → VLIW la realiza vía software → la complejidad hardware se reduce y se desplaza hacia el
software.
.
• La incapacidad para desarrollar compiladores que aprovechen al máximo las
VLIW han
características del enfoque VLIW.
fracasado
• Los problemas de compatibilidad entre generaciones de procesadores VLIW.
3.4. Arquitectura de un procesador VLIW genérico

La principal diferencia con respecto a un procesador superescalar es la ausencia de los elementos necesarios para
la distribución, emisión y reordenación de las instrucciones.
Los repertorios de instrucciones de las arquitecturas VLIW siguen una filosofía RISC con la excepción de que el
tamaño de instrucción es mucho mayor ya que contienen múltiples operaciones o mini-instrucciones.
Una instrucción VLIW → concatenación de varias instrucciones RISC que se pueden ejecutar en paralelo.
Las operaciones recogidas dentro de una instrucción VLIW no presentan dependencias de datos, de memoria
y/o de control entre ellas.
Página 2

lOMoARcPSD|215678
• Por lo general, el número y tipo de operaciones que contiene una instrucción VLIW se corresponde con el
número y tipo de unidades funcionales existentes en el procesador.
• Debido a la ausencia de hardware para la planificación, los procesadores VLIW no detienen las unidades
funcionales en espera de resultados.
• No existen interbloqueos por dependencias de datos ni hardware para detectarlas ya que el compilador se
encarga de generar el código objeto para evitar estas situaciones. Para ello recurre a la inserción de
operaciones NOP.
Código ejemplo Instrucciones VLIW
El no poder • El código objeto de un procesador VLIW es de mayor tamaño que el

rellenar equivalente para un procesador superescalar.
completamente
una instrucción • No se aprovechan al máximo los recursos del procesador ya que se tienen
VLIW tiene dos unidades funcionales ociosas, los buses transmiten información carente de
consecuencias: valor y las memorias cachés pierden parte de su eficiencia.
Predecir qué accesos a memoria producirán fallos de caché es muy complicado. Esto condiciona a que las
memorias caché sean bloqueantes, es decir, que tengan la capacidad de poder detener todas las unidades
funcionales.
3.5. Planificación estática o basada en el compilador

El compilador VLIW recibe como entrada el código fuente de una aplicación, realiza una serie de tareas
encaminadas a optimizar el código.
• Un código intermedio
Estas tareas pasan
por producir tres • Un grafo del flujo de control
elementos
• Un grafo del flujo de datos
• Las únicas dependencias de datos que permanecen en él son las verdaderas, las RAW.
• Las WAW y las WAR se han eliminado
Para poder generar un grafo de flujo de control es necesario conocer los bloques básicos de que consta el código
intermedio.
Un bloque básico → se compone de un grupo de instrucciones que forman una línea de ejecución secuencial por
lo que en su interior no existen instrucciones de salto con la salvedad de la última: no hay puntos intermedios de
entrada y salida.
Página 3

lOMoARcPSD|215678

• Una instrucción etiquetada (es decir, que es posible destino de un salto) o la siguiente
Para obtener los instrucción a una instrucción de salto establecen el comienzo de un bloque básico o
bloques básicos instrucción inicial.
se analiza el
código teniendo • El bloque básico se compone por todas las instrucciones que hay desde la instrucción inicial
en cuenta: hasta la siguiente instrucción de salto que se detecte.
• Los bloques se numeran de forma secuencial. La interconexión de las entradas y salidas de
los diferentes bloques básicos conforma el diagrama de flujo de control.
Una vez que se conocen los bloques básicos que hay en el programa, las instrucciones de cada bloque se
combinan para formar instrucciones VLIW. Para ello se recurre al grafo de flujo de datos que tiene asociado cada
bloque.
Grafo de flujo de datos → es un grafo dirigido en el que los nodos son las instrucciones de un bloque básico, y
los arcos se inician en una instrucción de escritura en un registro (instrucción productora) y tienen como destino
una instrucción que lee el valor de ese registro (instrucción consumidora).
De esta forma, el grafo de flujo de datos muestra las secuencias de instrucciones que no presentan dependencias
entre ellas y, por lo tanto, son susceptibles de combinar para formar instrucciones VLIW. A la combinación de
instrucciones de un único bloque básico para producir instrucciones VLIW se le denomina planificación local.
Algunas técnicas • Desenrollamiento de bucles (Apdo 3.6)

basadas en la
planificación local
• La segmentación software (Apdo 3.7)
• Planificación local está limitada.
Planificación global → combinar instrucciones de diferentes bloques básicos con el fin de producir una
planificación con mayor grado de paralelismo.
Los inicios de los bloques quedan
determinados por las instrucciones
etiquetadas y por las instrucciones
situadas a continuación de un salto
condicional o incondicional.
Página 4

lOMoARcPSD|215678
TresProcesadores
líneas VLIW y Procesadores vectoriales
paralelas de
ejecución
Grafo de flujo
de datos
• Dos operaciones de suma/resta (un ciclo de latencia)

• Una operación de multiplicación/división (tres ciclos de latencia)
Consideraciones • Una operación de carga (dos ciclos de latencia)
sobre formato de
• Una de almacenamiento (dos ciclos de latencia)
instrucción → admite
• Las instrucciones de salto son consideradas como instrucciones de
suma/resta que escriben en el registro contador de programa (un ciclo
de latencia)
Secuencia planificada de instrucciones VLIW
• No es posible ocupar todas las operaciones.
Si se considera que las instrucciones El programa consume 100

VLIW tienen una longitud de 20 bytes de almacenamiento en
bytes. El desaprovechamiento del memoria pero solo un 36 %
→ →
código VLIW es del 64 % está ocupado por operaciones
Cada operación básica ocupa 4
útiles.
bytes.
Página 5

lOMoARcPSD|215678

3.6. Desenrollamiento de bucles
loop unrolling → permite aprovechar el paralelismo existente entre las instrucciones que componen el cuerpo de
un bucle. La técnica consiste en replicar múltiples veces el cuerpo del bucle utilizando diferentes registros en cada
réplica y ajustar el código de terminación en función de las veces que se replique el cuerpo.
• Reduce el número de iteraciones del bucle.
Planificación más
• El total de instrucciones ejecutadas es menor ya se eliminan efectiva
saltos y se reduce el número de instrucciones de
Ventajas
incremento/decremento de los índices que se utilicen en el
bucle. ⇒
• Se proporciona al compilador un mayor número de
oportunidades para planificar las instrucciones ya que al
desenrollar el bucle queda mucho más cálculo al descubierto Generar código VLIW
al incrementarse el tamaño de los fragmentos de código lineal. más compacto
El bloque básico se compone por todas las instrucciones que
hay desde la instrucción inicial hasta la siguiente instrucción
de salto que se detecte.
Ejemplo
Se desenrolla el cuerpo del bucle
El código representa un bucle en el que

se realiza la suma de una constante,
almacenada en el registro F2, a todos
los elementos de un vector
almacenado en memoria cuyos
elementos son de doble precisión, es
decir, tienen una longitud de 8 bytes.
El índice que permite acceder a los
elementos del bucle se almacena en el
registro entero R1, que inicialmente
contiene la posición en memoria que
ocupa el último elemento del vector.
3 Unidades funcionales:
• Operaciones enteras (un ciclo de latencia)
• Operaciones en coma flotante (tres ciclos de latencia)
• Operaciones de carga/almacenamiento (dos ciclos de
latencia).
• Las operaciones de salto se ejecutan en la unidad entera
con un hueco de retardo de un ciclo por lo que permiten la
planificación de una instrucción a continuación.
Decremento
adelantado
4 bytes Página 6

lOMoARcPSD|215678

• La suma en coma flotante no se inician en el primer ciclo sino en el tercero ya que
es necesario tener en cuenta el retardo asociado a las instrucciones de carga,
esto es, dos ciclos.
• Las instrucciones de almacenamiento que deben esperar a que los resultados de

las operaciones de suma en coma flotante estén disponibles.
• La dependencia WAR existente entre la lectura del registro R1 por las

instrucciones de almacenamiento y su escritura por la instrucción SUBI se ha
resuelto teniendo en cuenta el efecto que produce el decremento adelantado del
índice. Las cuatro instrucciones de almacenamiento se modifican para recoger el
decremento adelantado del registro R1: como se decrementa por adelantado en
32, se suma un valor de 32 a los desplazamientos de los almacenamientos, 0, -8,
-16 y -24, dando como resultado que el adelanto en la escritura de R1 provoque
que los nuevos desplazamientos tengan que pasar a ser 32, 24, 16 y 8.
Problema que plantea el tamaño del código VLIW.
Si la instrucción VLIW y cada operación escalar necesitan un tamaño de 12 y 4 bytes, respectivamente, el espacio
de almacenamiento desaprovechado es, aproximadamente, del 50%.
Las instrucciones VLIW → 9 instrucciones*12 bytes = 108 bytes

Operaciones originales → 14 instrucciones*4 bytes = 56 bytes
Bucle original → 5 instrucciones*4 bytes = 20 bytes
Donde sí se aprecia una mejora es en el rendimiento. Si el vector constase de 1000 elementos
• Bucle original sin aplicar NADA 1000 veces → 1000 iteraciones*5 instrucciones = 5000 ciclos
* En el mejor de los casos, supuesta una segmentación ideal y sin riesgos.
• El cuerpo del bucle desenrollado cuatro veces → 250 iteraciones*14 instrucciones= 3500 ciclos.
• El VLIW → 250 iteraciones*9 instrucciones = 2250 ciclos
3500 − 2250
= 55,55% 𝑚𝑚á𝑠𝑠 𝑟𝑟á𝑝𝑝𝑝𝑝𝑝𝑝𝑝𝑝
2250
Comparación con la versión VLIW que se obtendría del bucle original sin recurrir a ninguna técnica de
planificación local.
2 ciclos
3 ciclos 1 ciclo
• 6 * 12 (bytes/instrucción) = 72 bytes, de los cuales solo 20 bytes están ocupados con operaciones.
• Velocidad de ejecución → si el vector constase de 1000 elementos se tardaría en procesarlo 6000 ciclos
de reloj frente a los 2250 ciclos obtenido tras aplicar desenrollamiento.
6000 − 2250
= 166,66% 𝑚𝑚á𝑠𝑠 𝑟𝑟á𝑝𝑝𝑝𝑝𝑝𝑝𝑝𝑝
2250
Página 7

lOMoARcPSD|215678

3.7. Segmentación software
La técnica consiste en producir un nuevo cuerpo del bucle compuesto por la intercalación de instrucciones
correspondientes a diferentes iteraciones del bucle original. Al reorganizar un bucle mediante segmentación
software, siempre es necesario añadir unas instrucciones de arranque (el prólogo) antes del cuerpo del bucle y
otras de terminación tras su finalización (el epílogo).
• Instrucciones A, B, C y D → cada una un ciclo de reloj

• Una dependencia RAW con la instrucción que la precede → D depende C, C depende B, B depende A.
• Tras tres iteraciones del bucle original aparece un patrón de ejecución compuesto por instrucciones
pertenecientes a cuatro iteraciones diferentes del bucle original y que ya no presentan dependencias RAW
entre ellas.
• Prólogo del nuevo bucle.
• Epílogo.
Planificación policíclica → mediante esta técnica se ejecutan al mismo tiempo instrucciones provenientes de
múltiples iteraciones.
Ejemplo
Latencias
• Dos ciclos para los accesos a memoria.

• Tres ciclos para las operaciones en coma flotante.
• No se han incluido las instrucciones que decrementan el valor de
R1 aunque sí se ha reflejado el necesario decremento en los
desplazamientos de las instrucciones de carga y almacenamiento
Página 8

lOMoARcPSD|215678
Para un vector de 1000

unidades, esto se
repetiría 1000 veces.
No hay ningún tipo de
dependencia de datos.
Si las instrucciones VLIW son de 16 bytes, el tamaño total del código es de (11 inst.*16 byt/inst).= 176 bytes.
En lo referente al tiempo para procesar un vector de 1000 elementos:
• 5 corresponderían al prólogo.
La aproximación VLIW
• 5 al epílogo.
emplearía 1010 ciclos.
• 1000 a las iteraciones del bucle.
Aunque el concepto en que se basa es sencillo, la segmentación software puede llegar a ser extremadamente
complicada de aplicar hay instrucciones condicionales en el cuerpo del bucle que impiden la aparición de un
patrón de comportamiento regular.
3.8. Planificación de trazas (trace scheduling)

Es una técnica de planificación global.
1. Selección de la traza. Encontrar un conjunto de bloques

Traza = camino de ejecución más básicos que formen una secuencia de
Planificación de trazas probable. código sin bucles.
2. Compactación o compresión de la traza
• Se recorre un vector de números enteros, A, y dos vectores de valores

en coma flotante, X e Y.
8 bytes 4 bytes
• En cada iteración del bucle, y en función del contenido de A[i] , se
incrementa X[i] o se decrementa Y[i] con una constante almacenada en
F2
A pesar de ello se hace con

decremento Código intermedio
R1 puntero a A[i]
R2 puntero a X[i]
R3 puntero a Y[i]
Página 9

lOMoARcPSD|215678

3 U.U.F.F. con ciclos de latencia:
2 3 1
F4
Ruta de ejecución más probable:

→ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 16, 17 → 12 ciclos
(caso A[i] == 0)
Ruta menos probable:
→ 1, 2, 3, 4, 10, 11, 12, 13, 14, 15, 16, 17 → 12 ciclos
(caso A[i] <> 0)
Algunos de los posibles desplazamientos de operaciones que se pueden realizar dentro de una traza
Se podrían desplazar antes de la condición lo que obligaría a anular

sus efectos mediante un código de compensación en caso de que no
fuese necesaria su ejecución. Esto se ha representado en la figura
mediante el bloque etiquetado como -B1 que indica que es necesario
realizar las operaciones que anulen el efecto de la ejecución del
contenido de B 1.
Situaciones en las que un bloque que se encuentra en un punto de ejecución común puede desplazarse con el
objetivo de producir código más compacto.
• Conocer cuál es la secuencia de ejecución más probable.

• Conocer las dependencias de datos existentes para
Las consideraciones que debe realizar garantizar su mantenimiento.
el compilador para desplazar • La cantidad de código de compensación que es necesario
operaciones dentro de una traza son las añadir.
siguientes:
• Saber si compensa el desplazamiento de operaciones
dentro de la traza, midiéndose el coste tanto en ciclos de
ejecución como en espacio de almacenamiento.
Página 10

lOMoARcPSD|215678

Ejemplo
Aplicando el desplazamiento de
operaciones del bloque B1
decremento de 2 ciclos
Ruta de ejecución más probable: 1, 2, 3, 4, 5, 6, 7, 8, 15, 16 → 10 ciclos → respecto a la no
planificación
1, 2, 3, 4, 5, 6, 8, 9, 10,
Ruta menos probable: → 15 ciclos → Incremento de 3 ciclos
11, 12, 13, 14, 15, 16
Aunque la reducción no es muy elevada, el tiempo medio de ejecución del código planificado será mejor
que el código original siempre que se cumpla la siguiente expresión:
[10 ciclos * p + 15 ciclos * (1 - p) < 12 ciclos * p + 12 ciclos * (1 - p)]

p es la probabilidad de que la rama (A[i] ==0) sea la ejecutada.
Uno de los problemas que presenta la planificación de trazas: a mayor cantidad de operaciones
desplazadas, mayor es la penalización en que se incurre cuando se realiza una predicción errónea.
Página 11

lOMoARcPSD|215678

3.9. Operaciones con predicado
Tratar las instrucciones condicionales como cualquier otra instrucción
Operaciones con predicado operaciones condicionadas operaciones con guarda
= =
(predicated operations) (conditioned operations) guarded operations
Una operación con predicado una instrucción en la que su resultado se almacena o se descarta dependiendo del
valor de un operando que tiene asociado.
un registro de un bit que se

• p = 1 → resultado de la
añade como un nuevo
operación se almacena
operando de lectura en cada
Operando = predicado → → Instrucción (p)
una de las operaciones que
conforman una instrucción • p = 0 → resultado de la
VLIW operación se anula
Poner a “1” P1 o P2 en función de la comparación

Ejemplo de R1 y el nº #50
Almacena el resultado de ADDI si P1 = “1”
Código fuente de un bucle Código intermedio Código intermedio aplicando operaciones con
genérico predicado
2 ciclos 3 ciclos 1 ciclo
Instrucciones VLIW derivadas del código intermedio con

Instrucciones VLIW derivadas del código intermedio
operaciones condicionadas
• VLIW sin operaciones condicionadas 11 y 9 ciclos según rama.

• VLIW con operaciones condicionadas 8 ciclos.
Página 12

lOMoARcPSD|215678

Ejemplo
3.10. Tratamiento de excepciones

Las técnicas vistas hasta ahora se basan en la predicción de los resultados de los saltos condicionales. Habrá que
establecer mecanismos para el tratamiento de las excepciones (interrupciones).
Centinelas = Un fragmento de código que indica que la operación ejecutada de forma especulativa con la que
está relacionado ha dejado de serlo.
El compilador marca las operaciones especulativas con una etiqueta y en el lugar del programa
en el que estaba el código especulado que ha sido desplazado sitúa un centinela vinculado a esa
etiqueta.
Esta estrategia se implementa mediante una especie de buffer de terminación en el que las
instrucciones se retiran cuando les corresponde salvo las marcadas como especulativas, que se
retirarán cuando lo señale la ejecución del centinela que tienen asociado.
3.11. El enfoque EPIC

Los repertorios de instrucciones VLIW no son compatibles entre diferentes implementaciones.
Problemas La planificación estática de las instrucciones de carga por parte del compilador resulte muy
del VLIW complicada.
puro La importancia de disponer de un compilador que garantice una planificación óptima del código
de forma que se maximice el rendimiento del computador y se minimice el tamaño del código.
EPIC (Explicitly Parallel Instruction Computing)

El objetivo de EPIC es retener la planificación estática del código pero mejorarla con características arquitectónicas
que permitan hacer frente dinámicamente a diferentes situaciones, tales como retardos en las cargas o unidades
funcionales nuevas o con diferentes latencias.
Es el compilador el que determina al agrupamiento de instrucciones pero, a la vez, comunica de forma
explícita en el propio código cómo se ha realizado el agrupamiento.
Página 13

lOMoARcPSD|215678
A :=B+C
• Dos unidades de carga/almacenamiento (2 ciclos de latencia)

Procesador VLIW • Una unidad funcional para operaciones en coma flotante (2 ciclos de latencia)
• Una unidad para operaciones enteras y saltos (1 ciclo de latencia).
Código producido por el compilador
Se puede emitir en
paralelo con ella la
siguiente instrucción que
aparezca en el código
NO se puede emitir en
Código VLIW paralelo con ella la siguiente Código EPIC
instrucción que aparezca en
el código
De las 20 16 NOPs
operaciones 4 Útiles
• Planificación estática con paralelismo explícito.

Características • Operaciones con predicado.
arquitectónicas
• Descomposición o factorización de las instrucciones de salto condicional.
más
destacadas del • Especulación de control.
estilo EPIC • Especulación de datos.
• Control de la jerarquía de memoria.
Página 14

lOMoARcPSD|215678

3.12. Procesadores vectoriales
Son máquinas que permiten la manipulación de vectores → Operadores fuente y destino son vectores.
Sumar dos vectores A y B de 64 elementos, la suma del elemento A[i] al B[i] no implica ningún tipo de dependencia
con la operación previa, es decir, la suma del elemento A[i-1] al B[i-1], o con la suma del A[i-2] al B[i-2], etc.
Cálculo con un bucle
→ 1. Cálculo vectorial.
3.13. Arquitectura vectorial básica
El número de registros vectoriales. 64 ÷ 256

Características MVL (Maximum Vector Length-
El número de elementos por
del fichero de Máxima Longitud del Vector).
registro.
registros 8 ÷ 256
vectoriales El tamaño en bytes de cada
8 bytes
elemento.
• Las unidades funcionales vectoriales están segmentadas y pueden iniciar una operación en cada ciclo de
reloj.
• Son necesarios mecanismos hardware que detecten los riesgos estructurales y los riesgos de datos que
pueden aparecer entre las instrucciones vectoriales y escalares
• Las unidades funcionales vectoriales de algunos procesadores es que pueden estar internamente
organizadas en varios lanes o carriles con el objeto de aumentar el número de operaciones que pueden
procesar en paralelo por ciclo de reloj.
o Básicamente, una unidad funcional con n carriles implica que, internamente, el hardware necesario
para realizar la operación se ha replicado n veces de forma que el número de ciclos que se emplea
en procesar un vector se reduce por un factor de n.
Página 15

lOMoARcPSD|215678

Ejemplo
C: =A+B A, B, C son registros vectoriales de 20 elementos.
2 etapas
Hay que incrementar el número de

puertos de lectura y escritura de todos
los registros vectoriales para poder
suministrar en cada ciclo de reloj
elementos a los carriles.
• Se engloban dentro de la categoría SIMD (Single Instruction -Multiple

Data).
Otra estructura que aprovecha
• Cuenta con una unidad de procesamiento vectorial, una unidad escalar y
el paralelismo de datos es 
una unidad de control que discrimina según el tipo de instrucción.
Procesador matricial: • La principal diferencia es que el procesador matricial con n elementos de
Mal llamado procesador vectorial
procesamiento puede procesar de forma simultánea en el mismo ciclo de
reloj un vector de n elementos
Página 16

lOMoARcPSD|215678

3.14. Repertorio genérico de instrucciones vectoriales
Similar al de las operaciones escalares
Instrucción
vectorial
Ejemplo del bucle DAXPY (Double Precision A Times X Plus Y)
Y(i) = a*X(i) + Y(i) con vectores de 64 elementos de 8 bytes
Código escalar: Se considera que la longitud de los vectores es de

64 elementos, en la aproximación escalar se
ejecutan 578 instrucciones (2 + 9 * 64).
Código vectorial:
CUESTIONES
¿Cómo proceder cuando la longitud del vector es
diferente al número de elementos de un registro • El registro de longitud vectorial VLR (Vector
vectorial? Length Register) → Controla la longitud de
¿Qué sucede cuando los elementos del vector se cualquier operación vectorial.
almacenan de forma uniforme pero no consecutiva en
memoria? • El registro de máscara VM (Vector Mask).
¿Cómo se vectoriza el cuerpo de un bucle que contiene
instrucciones ejecutadas condicionalmente?
Página 17

lOMoARcPSD|215678

El problema de ubicar en memoria los elementos de un vector de forma no consecutiva surge cuando hay que
almacenar estructuras de datos que presentan dimensiones superiores a la unidad, tal y como sucede, por
ejemplo, con los arrays bidimensionales. Un ejemplo de esta problemática aparece al multiplicar dos matrices de
100x100 almacenadas en los arrays A y B:
SOLUCIÓN:
Instrucciones especiales →
Vectorizar bucles en cuyo cuerpo hay Una máscara de MVL bits de longitud almacenada en el
→
instrucciones ejecutadas condicionalmente. registro especial VM. El valor del bit que ocupa la
Dependiendo de la condición, ciertos elementos posición i en la máscara determina si se realizarán (bit a
de un vector no tengan que ser manipulados. 1) o no (bit a 0).  Instrucciones especiales
Ejemplo
3.15. Medida del rendimiento de un fragmento de código vectorial

Factores que • La latencia en producir el primer resultado o tiempo de
afectan al arranque.
tiempo de • El número de elementos a procesar por la unidad
ejecución funcional.
• El tiempo que se tarda en completar cada resultado o
Tn tiempo por elemento.
Tarranque → El tiempo de arranque es similar al número de segmentos de que constan ya que es el tiempo que
transcurre desde que se solicita el primer bloque de datos del vector hasta que se dispone del mismo para
ser tratado por la unidad funcional.
Número de etapas en las que está segmentada la unidad funcional.
Unidad vectorial de 6 etapas (1 ciclo/etapa) → 6 ciclos.
Telemento → El tiempo que se tarda en completar cada uno de los restantes n elementos (Unidad segmentada→1
ciclo).
Página 18

lOMoARcPSD|215678
Unidad
funcional de
10 etapas
Si no hay riesgos estructurales ni

dependencias verdaderas → Planificación por convoy o paquetes
Situaciones
Si hay riesgos o interdependencias → Esperar a que los operandos estén disponibles.
3.15.1.1. Rendimiento de un procesador vectorial en FLOPs por ciclo
→ A mayor Rn mayor rendimiento
2 convoyes de una única instrucción (b)
Ejecución de un convoy de 2 instrucciones
Encadenamiento (chaining) → El encadenamiento permite que una unidad funcional pueda comenzar a operar
tan pronto como los resultados de la unidad funcional de que depende estén disponibles.
Página 19

lOMoARcPSD|215678
Convoyes sin solapamiento Convoyes con solapamiento

Ejecución de dos convoyes de instrucciones con encadenamiento entre unidades.
3.16. La unidad funcional de carga/almacenamiento vectorial

El elemento hardware más crítico en un procesador vectorial para poder alcanzar un rendimiento óptimo es la
unidad de carga/almacenamiento. La razón de ello es que debe ser capaz de poder intercambiar datos con los
registros vectoriales de forma sostenida y a una velocidad igual o superior a la que las unidades funcionales
aritméticas consumen o producen nuevos elementos, esto es, a Telemento
Solución → organizando físicamente la memoria en varios bancos o módulos y distribuyendo el espacio de
direccionamiento de forma uniforme entre todos ellos.
• Tiempo de arranque es igual a Ta ya que es el
tiempo que transcurre desde que se solicita el
primer elemento del vector al sistema de
memoria hasta que está disponible en el puerto
de lectura del banco para su posterior
Operación de transferencia al registro vectorial.
carga de un
• El tiempo por elemento se considera como el
registro vectorial
número de ciclos que se consumen en transferir
el dato ya disponible en el banco de memoria al
registro vectorial (por lo general, inferior a un
ciclo pero se iguala a uno para equipararlo al
T elemento de las unidades funcionales). el tiempo que consume una operación
• El tiempo por elemento se considera como el de acceso a memoria para un vector de
tiempo que se emplea en transferir un elemento n elementos =
desde un registro vectorial al puerto de escritura
Operación de
del banco de memoria.
escritura en
• El tiempo de arranque se puede ver como el
memoria
tiempo que emplea el banco en escribir el último
elemento del vector en una posición del banco
de memoria.
La lectura de los n elementos de que consta un vector supondría un coste de n * Ta ciclos, lo que es totalmente
inadmisible.
Para poder ocultar toda esta latencia es fundamental dimensionar correctamente el número de bancos de
memoria de forma que solo se vea el tiempo de acceso correspondiente al primer elemento del vector y que los
tiempos de acceso de los demás elementos queden ocultos. Esto se consigue distribuyendo los n elementos de
un vector entre m bancos de memoria para que se solapen.
Un dimensionamiento correcto  m ≥ Ta (Ta en ciclos de reloj)
Página 20

lOMoARcPSD|215678
• Síncrono
Solapamientos
• Asíncrono
Síncrono
Asíncrono
Solicitar simultáneamente un dato a los m bancos cada
Solicitar los elementos de que consta el vector a cada
Ta ciclos. uno de los m bancos de forma periódica con periodo Ta
con un desfase entre bancos consecutivos de Telemento
Realizada la primera petición y transcurridos Ta ciclos
ciclos.
estarán disponibles los m primeros elementos del
vector para ser transferidos al registro vectorial, lo que
De esta forma; comenzando en el ciclo 0 y cada Ta ciclos
consume m*Telemento ciclos.
el banco 0 solicita un dato, en el ciclo 1 y cada Ta ciclos
el banco 1 solicita un nuevo dato, y así sucesivamente
Ahora, cada Ta ciclos se realizan dos acciones:
hasta el banco m-1.
1. Se efectúa una nueva petición simultánea a
todos los bancos para extraer los m elementos
En el momento en que un banco tiene el dato disponible
siguientes del vector.
realiza dos acciones:
2. Se comienza a transferir ciclo a ciclo los m
1. Efectúa la nueva solicitud de dato.
elementos ya disponibles y que fueron
2. Transfiere el dato ya disponible al registro vectorial.
solicitados en la petición anterior.
La dirección de memoria
8 bytes →
23 → 3
8 bancos →
23 → 3 bits
64 elementos (de 8 bytes cada uno) ubicado a partir de la posición de memoria 80 en un sistema de memoria
organizado en 8 bancos con acceso asíncrono y con Ta de 6 ciclos
Ancho de palabra del banco = 8 bytes
Página 21

lOMoARcPSD|215678
3.17. Medida del rendimiento de un bucle vectorizado

Bucle DAXPY de n elementos con la técnica strip mining
Nº elementos
del vector
Posición en el
vector del 1º
elemento
Nº total de
secciones de
MVL elementos
Tbase: Es el tiempo que consumen las instrucciones escalares de Líneas 1, 2 y 3

preparación antes de abordar el bucle exterior.
Tbucle: Son los costes derivados de ejecutar en cada iteración del bucle Líneas 4, 5, 9, 10
exterior las instrucciones escalares necesarias para realizar el y 11
Componentes
seccionamiento.
del coste
Tarranque: Es la suma de los tiempos de arranque visibles de las unidades
funcionales que se utilizan en cada convoy de instrucciones.
Telemento: Es igual al número de convoyes en que se organizan las Líneas 6, 7 y 8.
instrucciones vectoriales que se derivan del bucle interior
Valor entero inmediatamente superior
Otra medida de rendimiento:
Ejemplo
Bucle DAXPY para vectores de n elementos.
• Una unidad de suma (6 ciclos de El fragmento de código vectorial que se genera para realizar las
latencia). operaciones
• Una unidad de multiplicación (7 ciclos Y(i): =a*X(i)+Y(i)
de latencia).
• Una unidad de carga/almacenamiento
(12 ciclos de latencia).
• MVL es 64.
• La frecuencia de reloj es 500 MHz.
• VLR = 64
Página 22

lOMoARcPSD|215678
Página 23

lOMoARcPSD|215678

3.17.1. Caso 1: Sin encadenamiento de resultados entre unidades
Dado que hay cuatro convoyes, Telemento es 4 ciclos

Tarranque total es igual a la suma de los tiempos de arranque visibles de los cuatro convoyes.
Para n=1000 ⇒
FLOPs/ciclo
Para simplificar los cálculos, la expresión n/64 se puede

reemplazar por una cota superior dada por (n /64 + 1).
Nº oper. Vectoriales = 2 (1 ADDV y 1 MULTSV)
Página 24

lOMoARcPSD|215678

3.17.2. Caso 2: Con encadenamiento de resultados entre unidades
Página 25

lOMoARcPSD|215678

3.17.3. Caso 3: Con encadenamiento y dos unidades de carga/almacenamiento
Página 26

lOMoARcPSD|215678

3.17.4. Caso 4: Con encadenamiento, dos unidades de carga/almacenamiento y
solapamiento entre convoyes dentro de la misma iteración
Página 27

lOMoARcPSD|215678
Página 28

lOMoARcPSD|215678
Procesamiento paralelo
4. PROCESAMIENTO PARALELO ................................................................2

4.2. Introducción ........................................................................................................................................ 2
4.3. Tipos de plataformas de computación paralela .............................................................................. 2
4.3.1. Organización basada en la estructura de control ......................................................................... 2
4.3.1.1. Paradigma Maestro/Esclavo ................................................................................................. 2
4.3.1.2. Paradigma SPMD (Single Program Multiple Data)............................................................... 3
4.3.2. Organización basada en el modelo de comunicación .................................................................. 3
4.3.2.1. Espacio de direcciones compartido ...................................................................................... 3
4.3.2.2. Paso de mensajes ................................................................................................................ 4
4.4. Sistemas de memoria compartida .................................................................................................... 4
4.4.1. Redes de interconexión ................................................................................................................ 4
4.4.1.1. Redes estáticas .................................................................................................................... 4
4.4.1.1.1. Unidimensionales ................................................................................................................. 4
4.4.1.1.2. Bidimensionales .................................................................................................................... 4
4.4.1.1.3. Tridimensionales ................................................................................................................... 5
4.4.1.1.4. Hipercubo.............................................................................................................................. 5
4.4.1.2. Caracterización de redes estáticas....................................................................................... 6
4.4.1.3. Redes dinámicas .................................................................................................................. 8
4.4.1.3.1. Basadas en bus .................................................................................................................... 8
4.4.1.3.2. Redes crossbar ..................................................................................................................... 8
4.4.1.3.3. Redes multietapa .................................................................................................................. 8
4.4.1.4. Comparación del rendimiento de redes dinámicas ............................................................ 11
4.4.2. Protocolos de coherencia de caché ........................................................................................... 12
4.5. Sistemas de memoria distribuida ................................................................................................... 14
4.5.1. Consideraciones generales sobre los clusters ........................................................................... 14
4.5.2. ¿Por qué clusters? ...................................................................................................................... 15
4.5.3. ¿Cuándo y cómo utilizar un cluster? .......................................................................................... 15
4.5.4. Programación de clusters ........................................................................................................... 15
4.6. Rendimiento y costes en sistemas paralelos ................................................................................ 16
4.6.1. Factores que influyen en la velocidad computacional ................................................................ 16
4.6.1.1. Granularidad de los procesos ............................................................................................. 16
4.6.1.2. Factor de aceleración (speedup) ........................................................................................ 16
4.6.1.3. Ley de Amdahl .................................................................................................................... 17
4.6.1.4. Eficiencia............................................................................................................................. 17
4.6.1.5. Coste ................................................................................................................................... 18
4.6.1.6. Escalabilidad ....................................................................................................................... 18
4.6.1.7. Balance de carga ................................................................................................................ 18
4.6.2. Costes de la comunicación mediante paso de mensajes .......................................................... 19
4.6.3. Costes de la comunicación mediante memoria compartida ....................................................... 20
Página 4.1

lOMoARcPSD|215678
4. PROCESAMIENTO PARALELO
4.2. Introducción
Hoy en día los sistemas están basados en varios procesadores.
El procesamiento paralelo consiste en realizar más de una operación de manera simultánea
 Dos o más procesadores.

Características de
 Compartir el acceso a una memoria común.
un sistema
multiprocesador  Compartir acceso a canales de E/S, unidades de control y dispositivos
 Único sistema operativo
4.3. Tipos de plataformas de computación paralela
 Visión que el programador tiene de la plataforma, es decir, las

capacidades para expresar tareas paralelas (la estructura de control) y los
 Lógica
métodos de comunicación entre dichas tareas (el modelo de
Organizaciones comunicación).
 Memoria compartida
 Física  Estructura del hardware.
 Memoria distribuida
4.3.1. Organización basada en la estructura de control
 Descomposición iterativa
 Paralelismo algorítmico
 Descomposición geométrica
 Descomposición especulativa
Paradigmas
 Descomposición funcional
 Maestro/Esclavo
 SPMD (Single Program Multiple Data)
 Descomposición recursiva o divide y vencerás
4.3.1.1. Paradigma Maestro/Esclavo

Un maestro y varios esclavos.
 Descompone el problema en pequeñas tareas

 Distribuir estas tareas entre el conjunto de procesadores esclavos
Maestro
 Recoger los resultados parciales de cada esclavo
 Ordena y obtiene el resultado final del problema
Balance  Estático  Al comienzo de la computación

de
cargas  Dinámico  Durante la computación
Página 4.2

lOMoARcPSD|215678
4.3.1.2. Paradigma SPMD (Single Program Multiple Data)
Paradigma SPMD = paralelismo geométrico, estructural o
paralelismo a nivel de datos
Cada procesador ejecuta

básicamente el mismo código pero
sobre distintas partes de los datos.
4.3.2. Organización basada en el modelo de comunicación

 El espacio de direcciones único y compartido (memoria
Modelos compartida)
 El paso de mensajes.
4.3.2.1. Espacio de direcciones compartido

La red de
dos parámetros  Latencia de red
interconexión es
que caracterizan
determinante para
la velocidad de
la eficacia del  Ancho de banda
transferencia 
sistema 
La arquitectura más común para la comunicación es la de

bus, en la cual todos los procesadores y módulos de
memoria se conectan a un único bus.
El tiempo de acceso a memoria es el mismo para cualquier

palabra accedida por un procesador, por lo que se
denomina arquitectura de acceso uniforme a memoria (UMA
- Uniform Memory Access).
La escalabilidad no suele ser lineal y, además, llega a saturarse  Nº máximo de procesadores entre 16 y 32.
Algunas mejoras  dotar a cada procesador de una memoria local, en la que se almacena el código que se
está ejecutando en el procesador y aquellos datos que no tengan que ser compartidos.
NUMA - Non Uniform Memory Access  DSM - Distributed Shared Memory
Memoria compartida con acceso no uniforme a Memoria compartida con acceso no uniforme a
memoria memoria solo con memoria local
Mecanismos hardware  ccNUMA (caché-coherent NUMA)

dedicados a mantener la  COMA (Caché-Only Memory Access)
coherencia de caché
Página 4.3

lOMoARcPSD|215678
4.3.2.2. Paso de mensajes
Intercambio de información, en forma de mensajes, entre los diferentes procesadores que componen el sistema.
Elementos  Emisor  Envío

para describir  Receptor Operaciones  Recepción
el sistema de  Canal de comunicación básicas  Identificación
comunicación  Mensaje  Nº participantes
4.4. Sistemas de memoria compartida

Aspectos  La organización de la memoria principal.
para el  El diseño de la red de interconexión.
diseño  El diseño del protocolo de coherencia de la caché.
4.4.1. Redes de interconexión  Estáticas

 Dinámicas
4.4.1.1. Redes estáticas
Denominada red directa, es una red cuya topología queda definida de manera definitiva y estable durante la
construcción de la máquina paralela.
 Unidimensionales
 Bidimensionales
4.4.1.1.1. Unidimensionales Tipos
 Tridimensionales
 Puede realizarse más  Hipercubos
de una transferencia
simultáneamente
siempre que sea a
través de enlaces
diferentes
Lineal  Problemas de
comunicación cuando
el número de
Anillo procesadores es
elevado
Bidimensional ideal
4.4.1.1.2. Bidimensionales
Completamente conectada Red en estrella
Desventaja de que las comunicaciones

pueden verse comprometidas en un nodo
cuando el número de procesadores es
grande y se realizan comunicaciones entre
procesadores situados en los niveles
superiores
Página 4.4

lOMoARcPSD|215678
Aliviar la desventaja indicada  Red en árbol grueso (fat tree)
Redes tipo mesh  extensión de las redes lineales.
Cada procesador se conecta directamente con otros cuatro

procesadores salvo en los extremos
4.4.1.1.3. Tridimensionales
Mesh tridimensional
4.4.1.1.4. Hipercubo
 Dos procesadores se conectan entre sí, si y solo si sus etiquetas, en binario, tienen
exactamente un bit distinto en una posición determinada.
 Un procesador de un hipercubo de dimensión d se conecta directamente a d procesadores.
 Todo hipercubo de dimensión d puede dividirse en dos de dimensión d - 1. Para ello se
selecciona la posición de un bit y se agrupan todos los procesadores que tengan el mismo
Propiedades
valor (0/1) en esa posición. k = nº procesadores.
 Distancia de Hamming  el número total de posiciones de bits para los que las etiquetas
de dos procesadores son diferentes. El camino más corto entre dos procesadores.
o La distancia de Hamming entre dos procesadores de etiquetas a y b es el
número de bits a 1 que hay tras el resultado de la operación ⊕
 Nº procesadores= 2d
Particiones del hipercubo D-3
Se selecciona la posición de un bit y se agrupan todos los procesadores que tengan el mismo valor (0/1) en esa
posición.
Página 4.5

lOMoARcPSD|215678
Para cualquier grupo de k bits fijo, los procesadores que difieren en los demás d - k bits forman un subcubo de
dimensión d - k formado por 2d-k procesadores. Dado que con k bits se pueden obtener 2k combinaciones
diferentes, se tendrán 2k subcubos distintos.
k=2 y d=4  24-2=4 subcubos
2 bits más significativos 2 bits menos significativos
Distancia de Hamming  La distancia de Hamming entre dos procesadores de etiquetas a y b es el número de bits
a 1 que hay tras el resultado de la operación ⊕  El camino más corto entre dos procesadores.
Origen  nodo a = 0101
Destino  nodo b = 1011
El mensaje se transmite por las dimensiones para las que la posición de ⊕ 1, comenzando por el
bit menos significativo.
⊕ 0101 ⊕ 1011 1110
1. Bit 0101 porque 1110 primer

1  primer nodo 0111.
2. Bit 0111 porque 1110

segundo bit a 1  segundo
nodo 0011.
3. Bir 0011 porque 1110 tercer

bit a 1  tercer nodo 1011.
Éste es el destino final.
4.4.1.2. Caracterización de redes estáticas

La máxima distancia entre dos procesadores cualesquiera  el camino que los une
 Diámetro con el menor número de enlaces.
Menor distancia  Comunicaciones más rápidas.
La multiplicidad de caminos entre dos procesadores.
 Conectividad Como medida la conectividad de arco = menor número de arcos que deben
eliminarse para obtener dos redes disjuntas.
ancho de canal = el número de bits que pueden transmitirse simultáneamente por
el canal que comunica dos procesadores, que es igual al número de cables
físicos del enlace.
Parámetros
velocidad de canal = velocidad máxima con que se puede emitir por cada cable físico
ancho de banda = velocidad máxima con la que los datos pueden enviarse entre dos
enlaces de comunicación= (velocidad del canal)*(ancho de canal)
 Rapidez ancho de bisección = el mínimo número de enlaces de comunicación que deben
eliminarse para que la red quede dividida en dos partes iguales. Con ello, se
define el ancho de banda de bisección como el menor volumen de
comunicaciones permitidas entre dos mitades cualesquiera de la red con
igual número de procesadores.
ancho de banda de bisección = (ancho de bisección)*(ancho de banda del
canal)
Contar el número de enlaces de comunicación o la cantidad de cableado necesario
 Coste
en la red.
Página 4.6

lOMoARcPSD|215678
COMPLETAMENTE
CONECTADA ESTRELLA ARBOL BINARIO ARRAY ANILLO
LINEAL
MESH HIPERCUBO
MESH BIDIMENSIONAL
BIDIMENSIONAL CERRADO
p = nº de procesadores
d = dimensión de la red.
k = nº de procesadores en cada dimensión. (RADIO)
d-cubo k-arias
Hipercubo dimensión d = d-cubo 2-ario.
Anillo = 1-cubo p-ario
Nº procesadores = kd
Resumen
Red mesh
Bidimensional  Cada µP se conecta con otros 4, salvo los extremos.
Bidimensional cerrada Cada µP se conecta con otros 4, INCLUIDOS los extremos.
Mesh Cuadrada Nº de µP en cada dimensión iguales.
Mesh Rectangular Nº de µP en cada dimensión diferentes.
Tridimensional  Hipercubo
Dimensión d Es el nº de µP a que se conecta cada µP.

El valor de d es igual al nº de bits de codificación de cada nodo.
Página 4.7

lOMoARcPSD|215678
4.4.1.3. Redes dinámicas
Se adaptan a las necesidades de comunicación demandadas.
 Basadas en bus
Tipos  Crossbar (o matriciales)
 Multietapa
4.4.1.3.1. Basadas en bus
Un único procesador puede transmitir información por el bus.
La colisión de peticiones de acceso al bus se soluciona
usando una lógica de arbitraje o módulo de arbitraje.
 FIFO (First In First Out - Primero

Políticas de en Entrar Primero en Salir)
asignación del
 Round Robin (En círculo)
módulo de
arbitraje  LRU (Least Recently Used -
Menos Usando Recientemente)
El rendimiento se puede mejorar incluyendo una caché en

cada procesador.
4.4.1.3.2. Redes crossbar

Una red crossbar permite conectar p procesadores con q
elementos de memoria utilizando una matriz de conmutadores.
El nº de conmutadores es p x q.
La complejidad y el coste de la red aumenta en un orden
Las redes crossbar son de tipo no-bloqueantes.
4.4.1.3.3. Redes multietapa

Las redes multietapa suponen un compromiso intermedio entre las dos opciones anteriores.
Un conmutador binario sería un conmutador 2 x 2,

con orden (k)= 2
Una propiedad importante de las redes multietapa es que son redes bloqueantes. Esto significa que ciertas
permutaciones, o conexiones a través de la red, pueden a su vez bloquear otras conexiones.
Página 4.8

lOMoARcPSD|215678
Ejemplos de redes multietapa
Red Omega
Permutación por barajamiento perfecto entre sus etapas.
La permutación por barajamiento perfecto (perfect suffle), , cuyo dominio es el conjunto de enteros [0, n - 1], se
define como
k  el orden del conmutador utilizado

xm-1 xm-2 ... x1 x0  la representación binaria del entero x.
Del nodo origen se obtiene el destino

realizado un desplazamiento a la izda de
todos los bits.
011  110
110  101
Barajamiento perfecto inverso, en el que se

efectúa la misma operación pero con un
desplazamiento a la derecha.
El número de conmutadores necesarios para construir la red es ∙ , p = nodos entrada = nodos salida
El coste de la red de orden ∙ ∙ . Nº de etapas
Para una red omega con 4 procesadores el número de conmutadores necesarios será 4 4
Para 8 procesadores será 8 12
Para 16 procesadores será 16 32
Este ratio de crecimiento, y por tanto su coste, es menor que el de una red crossbar, que como vimos
anteriormente crece con orden .
 Cada paquete transmitido va precedido de la dirección del nodo destino en binario.

El algoritmo de  Los conmutadores de cada etapa deciden el camino por el que transmitir el paquete
encaminamiento dependiendo del valor del bit de la dirección destino correspondiente a la etapa
es actual. Si el bit es 0, se encamina por la salida superior, y si es 1, se utiliza la salida
inferior.
Página 4.9

lOMoARcPSD|215678
Ejemplo procesador 110 envía paquete a 100
Nº etapas= 8 3 etapas
Para 8 procesadores será 8 12 conmutadores
PROCESADOR
PROCESADOR 1 0 DESTINO
ORIGEN
El conmutador B observa
que el bit que le
corresponde es un 0 (100),
por lo que encamina el
paquete por su salida
superior.
El conmutador de la primera etapa,
marcado con una A en la figura, ve
que el bit que le corresponde de la 0
dirección destino es un 1 (100), Último conmutador también
por lo que encamina el paquete observa su bit
por la salida inferior hacia el correspondiente es 0 (100)
conmutador marcado con una B. y encamina el paquete por
0 su salida superior, llegando
éste a su destino correcto.
Nº lineas= /2 4 lineas 1
Red Baseline
Se construye recursivamente por bloques,

conectando los conmutadores de la etapa i con
ambos sub-bloques de la etapa i + 1.
La primera etapa se construye con un bloque que

tendrá un tamaño , siendo n el número de
entradas. La segunda etapa se construye con dos
sub-bloques de tamaño
2 2
y así recursivamente hasta llegar en la última etapa
a sub-bloques de tamaño 2 x 2.
ENCAMINAMIENTO:
0  se encamina por la salida superior

1  se utiliza la salida inferior.
CONEXIÓN ENTRE NODOS

DESPLAZAMIENTO A LA DCHA
Nodo 0010 se conecta con 0001
Nodo 1010 se conecta con 0101
Por cada columna quitar el bit MSB
Nodo 0010 quitamos MSB y queda
010 con desplazamiento a la dcha 001
Página 4.10

lOMoARcPSD|215678
Red Butterfly
Las salidas de un conmutador j en la etapa i (identificado como [i, j]) se conectarán a los conmutadores [i + 1, j] e [i
i
+ 1, j ⊕ 2 ] (es decir, difieren en el i-ésimo bit).
Para 16 procesadores será 16 32 conmutadores Nodo [2,4]

Nº etapas= 16 4 etapas
Unido con el [i + 1, j]  [3,4]
Unido con el [i + 1, j ⊕ 2i ] :
Modelo
0 i+13 básico de
i 2
j ⊕ 2  100⊕2  100⊕ 100=000 permutación
[3,0]
1
Encaminamiento
2 A  el conmutador conectado al nodo de origen.

B  el conectado al nodo destino.
Ambos representados en binario, se calcula la ruta
3
j ⊕ .
4 Ri = 0  Camino directo
La ruta entre A y B
5 Ri = 1  Camino cruzado
6
Los conmutadores de la red se pueden representar
y
no Diagrama de conmutadores
mbr
ar tal y como muestra la figura.
7
Queremos enviar un paquete desde el nodo 0100 al nodo 1000.
Nodo 0100 (origen)  conmutador 010

Nodo 1000 (destino)  conmutador 100
Ruta entre conmutadores R = 010 ⊕ 100 = 110.
Desde el conmutador 010 se debe tomar la conexión

110
directa al conmutador A.
110 Desde A se toma la conexión cruzada al conmutador B.
110 Desde B se toma la conexión cruzada para llegar al 100.
4.4.1.4. Comparación del rendimiento de redes dinámicas
Página 4.11

lOMoARcPSD|215678
4.4.2. Protocolos de coherencia de caché
 Varios procesadores pueden guardar en sus respectivas cachés locales una copia
Problema de
de un mismo bloque de memoria.
coherencia de
caché  Este bloque es modificado por cada procesador, por lo que es necesario que los
cambios realizados se comuniquen al resto de procesadores.
No incorporar un  Local, en el que el procesador accede a datos

protocolo de privados y puede utilizar una caché local.
Dos tipos
Solución coherencia de
de acceso  Remoto, en el que el procesador accede a datos
sencilla caché y centrarse externos que no se almacenan en caché. En este
a memoria
en la escalabilidad caso dichos datos pueden ser accedidos utilizando,
del sistema  por ejemplo, la técnica de paso de mensajes.
 Modificar datos Si un procesador modifica su caché local, el contenido de la

compartidos memoria principal y las copias de las cachés no serán coherentes.
Si proceso A  P1 y asigna la variable V = 10 (suponiendo que su
Factores que valor anterior fuese 0) y si es intercambiado a otro procesador P2
 Migración de
provocan antes de que la memoria principal se actualice, el valor de V que
procesos
problemas de obtiene A será 0 ya que el valor 10 solo está almacenado en la
coherencia caché de P1.
 Entrada/Salida Los datos escritos por el procesador de E/S en la memoria principal
mediante Acceso pueden ser inconsistentes con las copias existentes en las cachés
Directo a Memoria locales de los procesadores del sistema.
 Invalidar las copias

en las cachés del
dato modificado.
Soluciones
 Actualizar las copias

en las cachés del
dato modificado.
Un posible método para mantener la coherencia  monitorización del número de copias existentes y el estado de
cada copia.
Las líneas sólidas  acciones de los procesadores

Las discontinuas  acciones para asegurar la coherencia
El estado compartido corresponde a una variable que ha

sido cargada en las cachés de varios procesadores.
Cuando un procesador modifica una variable compartida
ésta pasa al estado sucio, y todas las copias de esa
variable en las cachés de otros procesadores pasan al
estado inválido. Para garantizar la coherencia, todos los
accesos sobre una variable inválida deberán ser servidos
por el procesador que tiene dicha variable en el estado
sucio.
Si un procesador realiza una lectura sobre una variable
Página 4.12

lOMoARcPSD|215678
inválida se propaga una acción C_lectura que actualiza el resto de copias, además de la memoria principal, y las
devuelve al estado compartido.
Si un procesador realiza una escritura sobre una variable inválida se propaga una acción C_escritura para invalidar
el resto de copias y posteriormente pasar dicha variable al estado sucio.
Si un procesador realiza una escritura sobre un bloque compartido se generará una acción C_escritura para
invalidar el resto de copias en las cachés, pasando la variable modificada al estado sucio. Finalmente, cuando un
procesador vacía su caché todos los bloques pasan al estado inválido.
Mecanismos hardware para implementar el protocolo de coherencia de caché basado en invalidación:

 Sistemas snoopy o de vigilancia del bus:
cada procesador monitoriza el tráfico de la
red en busca de transacciones.
La caché de cada procesador tiene

asociadas unas etiquetas que usa para
determinar el estado de sus bloques de
caché.
La principal limitación de los sistemas

snoopy es la limitación de ancho de banda
del bus.
 Sistemas basados en directorios. Usan un

mapa de bits (o bits de presencia) para almacenar la localización de las copias de caché que tiene cada
procesador en su caché.
 Puede incluirse en la memoria principal (con un sistema de directorio centralizado).

 Puede incluirse en las memorias locales de cada procesador (obteniendo un sistema
Este mapa de bits de directorio distribuido).
Si uno de los procesadores modifica el bloque, su estado pasa a sucio y el bit de
presencia correspondiente al otro procesador· se desactiva.
Página 4.13

lOMoARcPSD|215678
4.5. Sistemas de memoria distribuida

 Cada procesador dispone de su propia memoria.
 La comunicación se realiza por paso de mensajes, es decir,
para que un dato que reside en la memoria de un procesador
pase a la de otro, el primero debe construir un mensaje por
software.
 El paso de mensajes parece ser la estrategia dominante en
los sistemas con gran número de procesadores (mayor que
100), y es especialmente útil en entornos donde la ejecución
de los programas puede dividirse en pequeños subprogramas independientes.
tiempo requerido para realizar una operación básica de comunicación

tiempo requerido para realizar una operación básica de cálculo de los procesos
Uso adecuado del ancho de banda  cuidadoso reparto de los datos sobre los procesadores con el fin de
disminuir la granularidad de las comunicaciones
Un único computador con múltiples Procesadores masivamente paralelos

Los sistemas con memoria CPUs comunicadas por un bus de (MPPs - Massively Parallel
distribuida o datos. Processors)
multicomputadores pueden Múltiples computadores, cada uno
ser con su propio procesador, enlazados Cluster
por una red de interconexión.
 Un sistema Beowulf es un conjunto de nodos minimalistas conectados por un

medio de comunicación barato.
 Cada nodo de un Beowulf se dedica exclusivamente a procesos del
supercomputador.
 En una red de estaciones de trabajo (NOWs) suele existir un switch central
para realizar las comunicaciones, mientras que en un Beowulf el mecanismo
Beowulf
Tipos de clusters es más rudimentario: conexiones placa a placa por cable RJ-45 cruzado.
 La programación de un Beowulf es fuertemente dependiente de la arquitectura
y siempre se realiza por paso de mensajes.
 Para programar un Beowulf en primer lugar se diseña el modelo de
paralelismo, se observan cómo son las comunicaciones entre los nodos y se
implementan físicamente.
NOW
4.5.1. Consideraciones generales sobre los clusters

Topologías de los clusters Redes lineales
en función de las De anillo
conexiones punto a punto En estrella
Página 4.14

lOMoARcPSD|215678
4.5.2. ¿Por qué clusters?

Los clusters constituyen una alternativa de menor coste ampliamente utilizada y consolidada.
Los motivos que han hecho posible este hecho cabe destacar el gran progreso en la disponibilidad de
componentes de un alto rendimiento para PCs/estaciones de trabajo y redes de interconexión.
 Se pueden construir con un esfuerzo relativamente moderado.

 Son sistemas de bajo coste.
 Utilizan hardware convencional y accesible.
 Utilizan un sistema de comunicación basado en una red de área local rápida como Myrinet
o Fast Ethernet.
 Utilizan un software de libre distribución, como Linux, y algún entorno de programación
paralelo PVM (Parallel Virtual Machine) o MPI (Message Passing Inteiface).
Características
de los sistemas  Son sistemas escalables
clusters  Cada máquina de un cluster puede ser un sistema completo utilizable o aprovechable para
otros propósitos.
 Reemplazar un computador defectuoso de un cluster es trivial.
 El rendimiento y los recursos del cluster pueden crecer con el tiempo beneficiándose de
las últimas tecnologías computacionales y de redes.
 Debido a la estandarización se tiene la garantía de que los programas escritos para un
cluster funcionarán en cualquier otro con independencia del tipo de procesador de cada
nodo sin más que recompilar el código para esa arquitectura.
Las redes ordinarias no están diseñadas para el procesamiento paralelo.

Desventajas En los sistemas operativos monoprocesador existe muy poco software para tratar un cluster
como un único sistema.
4.5.3. ¿Cuándo y cómo utilizar un cluster?

Debe tenerse en cuenta el hardware de la máquina ya
que es preciso maximizar la relación entre el tiempo de
cálculo útil y el "perdido" en el paso de mensajes.
La clave consiste en descomponer el problema de tal

forma que cada procesador pueda operar el mayor
tiempo posible sobre su fragmento de los datos.
Es interesante utilizar un cluster si la aplicación es

suficientemente paralela y/o ha sido ya paralelizada.
Opciones para hacer Programar explícitamente el

que la aplicación sea paso de mensajes.
capaz de usar los
Utilizar herramientas que lo
computadores de un
hagan.
cluster
4.5.4. Programación de clusters

El modelo de memoria compartida es similar al de un tablón de anuncios con
acceso restringido. Hay que tener la seguridad de que la información que un
Paradigmas de programación procesador lee es semánticamente válida, y no son datos inválidos
El modelo de paso de mensajes. Menos intuitivo pero más cómodo para
transmitir información.
Página 4.15

lOMoARcPSD|215678
4.6. Rendimiento y costes en sistemas paralelos

Granularidad de los procesos
4.6.1. Factores que Factor de aceleración (speedup)
Ley de Amdahl
influyen en la
Eficiencia
velocidad Coste
computacional Escalabilidad
Balance de carga
4.6.1.1. Granularidad de los procesos

Granularidad gruesa Gran número de instrucciones secuenciales  No necesitan comunicación
Granularidad fina Pocas instrucciones secuenciales
A medida que se divide el problema en partes paralelas se llegará a un punto en el que el tiempo de comunicación
domine sobre el tiempo total de ejecución. Se puede utilizar la razón:
ó
→ ó
ó
4.6.1.2. Factor de aceleración (speedup)

ts es el tiempo de ejecución de un programa en un único procesador.
tp es el tiempo de ejecución en un sistema paralelo con M
procesadores.
M  Número de procesadores.
S(M)  incremento de la velocidad.
ú

ú
Todos aquellos pasos computacionales que se realizan en paralelo contabilizan solo como uno
La aceleración máxima absoluta de M se debería alcanzar cuando: la computación se puede dividir en procesos de
igual duración, cada proceso se localiza en un procesador y no hay sobrecarga (overhead), es decir:
 Los periodos en los que no todos los procesadores están realizando un

trabajo útil.
 Los cálculos adicionales que aparecen en el programa paralelo y que no
Factores que aparecen aparecen en el secuencial.
como sobrecarga en los
programas paralelos y
que limitan la aceleración
 El tiempo de comunicación para enviar mensajes.
Página 4.16

lOMoARcPSD|215678
4.6.1.3. Ley de Amdahl
f  la fracción del programa que no se puede dividir en tareas paralelas, 0 ≤ f ≤ 1 y se considera que no hay
sobrecarga cuando el programa se divide en tareas paralelas
Tiempo de computación necesario para ejecutar el programa en M procesadores
La parte secuencial está localizada

al comienzo del programa.
La razón para aumentar el número de procesadores debe ser para resolver problemas de tamaño mayor, y no para
resolver más rápidamente un problema de tamaño fijo.
El límite de Amdahl como el mayor factor de aceleración posible cuando el número de procesadores
disponibles tiende a infinito.
4.6.1.4. Eficiencia
E en función del factor de aceleración S(M)
Página 4.17

lOMoARcPSD|215678
4.6.1.5. Coste
El coste C (o trabajo) de una computación
ó ú
El coste de una computación secuencial  tiempo de ejecución ts,

El de una computación paralela es tp M.
El coste de una computación paralela 
Un coste óptimo de un algoritmo paralelo es aquel que es proporcional al coste (tiempo de ejecución) que tiene en
un sistema con un único procesador.
4.6.1.6. Escalabilidad
Escalabilidad hardware  Un diseño hardware que permite ampliar su tamaño para obtener una mejora en el
rendimiento.
Escalabilidad algorítmica  Un algoritmo paralelo puede soportar un incremento grande de datos con un
incremento bajo y acotado de pasos computacionales.
Escalabilidad  Si es que un sistema es escalable si el rendimiento del mismo se incrementa linealmente con
relación al número de procesadores usados para una cierta aplicación.
Los estudios de escalabilidad determinan el grado de afinidad entre una arquitectura determinada y una aplicación.
 Tamaño del sistema

 Frecuencia de reloj
 Tamaño del problema
Parámetros que afectan a la
 Tiempo de CPU
escalabilidad
 Capacidad de memoria
 Pérdidas (overhead) de comunicación
 Coste del sistema
4.6.1.7. Balance de carga

Balance de carga  consiste en distribuir de una forma equitativa
la carga computacional entre todos los
procesadores disponibles y con ello
conseguir la máxima velocidad de
ejecución.
Es muy difícil estimar de forma precisa el tiempo

de ejecución de todas las partes
Algunos sistemas pueden tener retardos en las
comunicaciones que pueden variar bajo diferentes
Antes de la ejecución
Estático Inconvenientes circunstancias, lo que dificulta incorporar la
de cualquier proceso.
variable retardo de comunicación en el balance.
Tipos A veces los problemas necesitan un número
indeterminado de pasos computacionales para
alcanzar la solución.
Las tareas se reparten
 Balance de carga dinámico centralizado.
entre los procesadores
Dinámico Tipos  Balance de carga dinámico distribuido o
durante la ejecución del
descentralizado.
programa.
Página 4.18

lOMoARcPSD|215678
Balance de carga dinámico centralizado.
El proceso maestro es el que tiene la colección completa de tareas a realizar.
Las tareas son enviadas a los procesos esclavos.
Cuando un proceso esclavo finaliza una tarea, solicita una nueva al maestro.
Esta técnica también se denomina programación por demanda o bolsa de trabajo.
Balance de carga dinámico distribuido o descentralizado.

Varios maestros y cada uno controla a un grupo de esclavos.
Para tareas de grano fino (tareas con muy poca carga computacional) y muchos esclavos
es apropiado distribuir las tareas en más de un sitio.
4.6.2. Costes de la comunicación mediante paso de mensajes

Latencia de comunicación  el tiempo necesario para preparar el mensaje y el tiempo que éste emplea en
atravesar la red de comunicación hasta su destino.
 Tiempo de inicialización (ts): Este tiempo incluye el tiempo en preparar el mensaje, el tiempo de
ejecución del algoritmo de enrutamiento y el tiempo de conexión entre el emisor y el enrutador.
 Tiempo de salto (th): Es el tiempo que tarda la cabecera de un mensaje en viajar entre dos
Parámetros
nodos
 Tiempo de transferencia por palabra (tw): Si el ancho de banda de un canal es r palabras por
segundo, su tiempo de transferencia por palabra es 1/r.
Cada nodo intermedio entre el emisor y el receptor reenvía el

mensaje únicamente cuando lo ha recibido y almacenado
Almacenamiento y reenvío completamente. Se supone un mensaje de tamaño m que se
(store-and-forward) transmite a través de ”l” enlaces intermedios. Donde en cada
enlace el mensaje tarda th para la cabecera y twm para el resto
del mensaje. El tiempo total:
El tiempo de salto en los sistemas paralelos actuales es

mucho menor que el tiempo de transferencia del mensaje
Algoritmos
de Se basa en los sistemas de enrutamiento de paquetes.
enrutamiento Divide cada mensaje en un número fijo de unidades llamados
dígitos de control de flujo (flow control digits o flits).
Corte y continuación ( cut- Antes de enviar el primer flit el emisor establece un camino
through) hasta el receptor mediante el envío de un paquete especial
llamado tracer. Una vez se ha establecido la conexión se
envían los flits uno tras otro, siguiendo todos la misma ruta.
Los nodos intermedios no esperan a recibir todo el mensaje,
sino que reenvían los flits según los van recibiendo.
Se supone un mensaje de m palabras que viaja a través de
una red con l enlaces. Si th es el tiempo de salto, la cabecera
del mensaje tardará un tiempo lth en llegar al receptor.
Página 4.19

lOMoARcPSD|215678
4.6.3. Costes de la comunicación mediante memoria compartida

 La disposición de los datos en memoria está determinada por el sistema.
La unidad de medida  La limitación en el tamaño de las caché puede provocar un problema de
para el coste de la hiperpaginación (thrashing).
comunicación de un  La sobrecarga (overhead) incluida por las operaciones de coherencia de caché
programa paralelo (invalidar y actualizar) es difícil de cuantificar.
mediante paso de  La localidad espacial es un fenómeno difícil de modelar.
mensajes es mucho  La lectura-anticipada de palabras juega un papel importante en la reducción de los
más sencillo que tiempos de acceso a los datos.
mediante el uso de  El fenómeno de false-sharing puede incluir una sobrecarga (overhead) importante en
memoria compartida. muchos programas. false-sharing  cuando diferentes procesadores acceden a
diferentes datos que están almacenados en el mismo bloque de caché.
RAZONES:  La competición por los recursos del sistema normalmente supone una de las
mayores sobrecargas (overheads) en sistemas de memoria compartida.
El acceso a datos remotos provoca la lectura de dichos datos para escribirlos en la caché local. Esto implica un
tiempo para las acciones de coherencia, la red de interconexión y el acceso a memoria.
El tiempo de acceso a una palabra remota se denomina como tw. El coste de compartir un bloque de datos de m
palabras será ts + mtw
Si el acceso es en modo lectura-escritura, el coste se incrementa en los accesos de los procesadores posteriores
al que escribe.
Página 4.20

IC2 Resumen

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

IC2 Resumen

Enviado por

Direitos autorais:

Formatos disponíveis

lOMoARcPSD|215678

Temas 1-4: Procesadores

Ingeniería de Computadores II (UNED)

Su distribución está prohibida | Descargado por Daniel Bar (danbbt@hotmail.com)

Su distribución está prohibida | Descargado por Daniel Bar (danbbt@hotmail.com)

 Dos etapas del RISC I (1982),

1.3. Procesadores RISC frente a procesadores CISC

La arquitectura tipo CISC dificultaba el paralelismo a nivel de instrucciones.

Ventajas de Al ser la lógica de control más simple, se facilita el diseño.

1.4. Clasificación de las arquitecturas paralelas

La contribución Replicación de elementos: Unidades

Su distribución está prohibida | Descargado por Daniel Bar (danbbt@hotmail.com)

Su distribución está prohibida | Descargado por Daniel Bar (danbbt@hotmail.com)

 Un SISD necesita 12 Intervalos.

Necesita tres intervalos de tiempo.

Necesita cuatro intervalos de tiempo.

- De datos. Una misma función sobre datos diferentes.

Su distribución está prohibida | Descargado por Daniel Bar (danbbt@hotmail.com)

Su distribución está prohibida | Descargado por Daniel Bar (danbbt@hotmail.com)

1.5. Evaluación y mejora del rendimiento de un computador

• Tiempo de respuesta: Tiempo que tarda el computador en procesar una entrada

• Productividad (throughput): Número de entradas procesadas por unidad de tiempo.

Medidas para • Funcionalidad: Tipos de entradas diferentes que es capaz de procesar.

TCPU= Tiempo de CPU de un program. o

CPIi= Nº medio de ciclos por instrucción de

NIi= Nº instrucciones de ese tipo

PARALELISMO CPE= Nº medio de ciclos entre inicios de

IPE= Nº medio de instruc. que se emiten

Noperaciones= Nº operaciones que realiza el

Su distribución está prohibida | Descargado por Daniel Bar (danbbt@hotmail.com)

Medida que puede variar con el programa

No es medida adecuada para todos los

p = rendimiento con la mejora

Su distribución está prohibida | Descargado por Daniel Bar (danbbt@hotmail.com)

p=Rendimiento con la mejora

Es decir, la máquina mejorada solo es un 14% mejor.

Tiempo con la mejora:

Su distribución está prohibida | Descargado por Daniel Bar (danbbt@hotmail.com)

1.6. Características de los procesadores segmentados

Su distribución está prohibida | Descargado por Daniel Bar (danbbt@hotmail.com)

1.7. Arquitectura segmentada genérica (ASG)

 El número de operandos que pueden tener las instrucciones aritmético-lógicas.

1.7.1. Repertorio de instrucciones de la ASG

Su distribución está prohibida | Descargado por Daniel Bar (danbbt@hotmail.com)

1.7.1.2. Transferencia de datos

Su distribución está prohibida | Descargado por Daniel Bar (danbbt@hotmail.com)

1.7.2. Implementación de la segmentación de instrucciones en la ASG

1. IF (lnstruction Fetch): Lectura de la instrucción de la caché de instrucciones.

Su distribución está prohibida | Descargado por Daniel Bar (danbbt@hotmail.com)

Su distribución está prohibida | Descargado por Daniel Bar (danbbt@hotmail.com)

 Los cerrojos o buffers de contención

1.8. Riesgos en la segmentación

Su distribución está prohibida | Descargado por Daniel Bar (danbbt@hotmail.com)

1.8.1. Riesgos estructurales

DUPLICAR LA UNIDAD FUNCIONAL PLANIFICACIÓN DE CÓDIGO

Su distribución está prohibida | Descargado por Daniel Bar (danbbt@hotmail.com)

1.8.2. Riesgos por dependencias de datos

Ejemplo instrucción i se ejecuta antes que la j

Para ASG solo existe el riesgo RAW

1.8.2.1. La reorganización de código

1. AL NO REORGANIZAR CÓDIGO  UNA DETENCIÓN (BURBUJA) DE 4 CICLOS

Su distribución está prohibida | Descargado por Daniel Bar (danbbt@hotmail.com)

Su distribución está prohibida | Descargado por Daniel Bar (danbbt@hotmail.com)