Folleto AMC3 2023

Ier Sem
2023
UNIVERSIDAD NACIONAL DE INGENIERIA

FACULTAD DE ELECTROTECNIA Y COMPUTACION
DEPARTAMENTO DE ARQUITECTURA Y SISTEMAS

ARQUITECTURA DE MÁQUINAS COMPUTADORAS III
Folleto de apoyo al estudiante

José L. Díaz Chow
José Leónidas Díaz Chow

Díaz - Medrano
IS 2013
Folleto de apoyo para el estudiante de la asignatura de
Arquitectura de Máquinas Computadoras III
Elaborado por
Ing. José Leónidas Díaz Chow
Última modificación: mayo de 2023

Universidad Nacional de Ingeniería, UNI.
Managua, Nicaragua.
Arquitectura de Máquinas Computadoras III Folleto de apoyo al estudiante
TABLA DE CONTENIDO
1 PARALELISMO Y MEJORA DEL RENDIMIENTO ..... 1

1.1 EVALUACION DEL DESEMPEÑO .......................................................................... 1
1.1.1 Medida de rendimiento .......................................................................................... 2
1.1.2 Métricas de desempeño .......................................................................................... 2
1.1.3 Consideraciones de efectividad-costo .................................................................... 3
1.1.4 Técnicas de análisis de desempeño ........................................................................ 4
1.1.5 Rendimiento: .......................................................................................................... 4
1.1.6 Factores que determinan el tiempo de ejecución ................................................... 6
1.1.7 Ley de Amdahl ....................................................................................................... 6
1.1.8 Cálculo del tiempo de Ejecución............................................................................ 8
1.1.9 Métricas populares de rendimiento ........................................................................ 9
1.2 REDUCCIÓN DEL TIEMPO DE EJECUCIÓN ....................................................... 12
1.2.1 Reducción del período de reloj. ........................................................................... 12
1.2.2 Reducción de la cantidad de instrucciones N. ...................................................... 12
1.2.3 Reducción del CPI................................................................................................ 13
1.2.4 Consecuencias de la ley de Amdahl ..................................................................... 13
1.3 MEJORAS AL SISTEMA DE MEMORIA ............................................................... 14
1.3.1 Jerarquía de memoria ........................................................................................... 14
1.3.2 Principio de localidad de referencia. .................................................................... 15
1.3.3 Cálculo de la aceleración del rendimiento en la jerarquía de memoria ............... 16
1.4 MEJORAS AL SISTEMA DE ENTRADA-SALIDA ............................................... 16
1.4.1 DMA .................................................................................................................... 17
1.4.2 Procesadores y Canales de E/S ............................................................................ 17
1.5 INTRODUCCIÓN AL PARALELISMO ................................................................... 17
1.5.1 Procesamiento paralelo ........................................................................................ 18
1.5.2 Diferentes mecanismos y técnicas de mejora del desempeño empleadas ............ 18
1.6 CLASIFICACIÓN DE LAS ARQUITECTURAS PARALELAS. ............................ 20
2 SEGMENTACION ......................................................... 22
2.1 INTRODUCCION ...................................................................................................... 22
2.2 RENDIMIENTO DEL PROCESADOR SEGMENTADO ........................................ 25
2.3 CLASIFICACION DE LOS PROCESADORES ENCAUZADOS. .......................... 26
2.4 EL PROCESADOR SEGMENTADO DLX .............................................................. 27
2.5 DIFICULTADES DE LA SEGMENTACION........................................................... 29

2.6 DEPENDENCIAS ESTRUCTURALES .................................................................... 30
2.6.1 TABLA DE RESERVA DEL DLX .................................................................... 30
2.6.2 RIESGOS ESTRUCTURALES EN EL DLX ..................................................... 31
2.6.3 TABLA DE RESERVA CON DEPENDENCIAS ESTRUCTURALES
RESUELTAS .................................................................................................................... 33
2.6.4 DATAPATH DEL DLX ...................................................................................... 34
2.7 DEPENDENCIAS DE DATOS.................................................................................. 35
2.7.1 TIPOS DE DEPENDENCIAS DE DATOS ........................................................ 35
2.7.2 TRATANDO LAS DEPENDENCIAS DE DATOS EN EL DLX ...................... 36
2.7.3 RESUMEN DE DEPENDENCIAS DE DATOS EN EL DLX ........................... 38
2.7.4 DATAPATH DEL DLX CON DEPENDENCIAS DE DATOS RESUELTAS . 40
2.8 DEPENDENCIAS DE CONTROL ............................................................................ 41
2.8.1 ADELANTANDO LA DEFINICION DEL SALTO ........................................ 41
2.8.2 DEPENDENCIAS DE DATOS EN BRx TRAS ADELANTAMIENTO A D/L 43
2.8.3 TRATAMIENTO DE LAS LATENCIAS DE CONTROL ............................... 44
2.8.4 DATAPATH DEL DLX CON LAS DEPENDENCIAS DE CONTROL
RESUELTAS .................................................................................................................... 47
2.9 EXCEPCIONES ......................................................................................................... 48
2.9.1 INTRODUCCION ............................................................................................... 48
2.9.2 EXCEPCIONES EN EL DLX ............................................................................. 48
2.10 SEGMENTACION NO LINEAL ............................................................................... 49
2.11 PROCESADORES MULTICICLO ............................................................................ 50
2.12 PLANIFICACION DE RECURSOS .......................................................................... 51
3 ARQUITECTURAS SIMD ............................................ 56

3.1 INTRODUCCIÓN ...................................................................................................... 56
3.1.1 Necesidad de procesamiento de Vectores y matrices .......................................... 56
3.1.2 Características y exigencias del procesamiento de Vectores / Matrices .............. 56
3.2 Tipos de Arquitecturas SIMD ..................................................................................... 57
3.2.1 Procesadores vectoriales o Vector Processors ..................................................... 57
3.2.2 Procesadores matriciales o Array Processors ....................................................... 58
3.3 Procesadores vectoriales Encauzados (Vector Processors) ........................................ 58
3.3.1 Cauces vectoriales ................................................................................................ 58
3.3.2 Maquinas M-M, Memorias entrelazadas y Procesamiento en flujo continuo ...... 58
3.3.3 Máquinas R-R y Encadenamiento de vectores.................................................... 59
3.4 Procesadores SIMD (Processor Arrays) ..................................................................... 60
3.4.1 Procesadores de arreglos de EPs. ......................................................................... 60
3.4.2 Enmascaramiento, limitando la estructura. .......................................................... 61

3.4.3 Importancia de VLSI en las Arquitecturas SIMD. ............................................... 61
3.5 Procesadores Sistólicos ............................................................................................... 61
3.5.1 Deficiencias de la taxonomía de Flynn. ............................................................... 61
3.5.2 Arreglos sistólicos ................................................................................................ 61
3.6 Procesadores de Frente de Onda ................................................................................. 62
3.6.1 Redes sincrónicas vs. redes asíncronas ................................................................ 63
3.6.2 WaveFront Array Processor ................................................................................. 63
3.7 Procesadores Asociativos ........................................................................................... 63
3.7.1 Procesadores Asociativos ..................................................................................... 63
3.7.2 Ejemplares ............................................................................................................ 63
3.8 Estructuras y algoritmos para Procesadores Matriciales. ........................................... 63
3.8.1 Estructuras de Interconexión – Comunicación EPs. ............................................ 64
3.8.2 Características de los Algoritmos matriciales. ..................................................... 64
4 ARQUITECTURAS MIMD. .......................................... 65

4.1. Introducción a los MIMD: Multiprocesadores .............................................................. 65
4.1 Clasificación de los sistemas MIMD. ......................................................................... 66
4.2 Estructuras de Interconexión. ..................................................................................... 66
4.2.1 Bus común............................................................................................................ 67
4.2.2 Conmutador Barra-Cruz. ...................................................................................... 68
4.2.3 Memorias Multipuerto ......................................................................................... 68
4.2.4 Redes Interconexión multietapa. .......................................................................... 69
4.2.5 Hipercubo. ............................................................................................................ 69
4.3 Acceso a recursos compartidos ................................................................................... 70
4.3.1 Arbitraje del bus ................................................................................................... 70
4.3.2 Exclusión mutua ................................................................................................... 70
4.4 Comunicación entre Procesadores .............................................................................. 71
4.5 Coherencia de cachés .................................................................................................. 71
4.6 Sistemas Operativos y lenguajes de programación MP .............................................. 72
4.6.1 Sistemas operativos: ............................................................................................. 72
4.6.2 Lenguajes: ............................................................................................................ 72
1 PARALELISMO Y MEJORA DEL RENDIMIENTO

1.1 EVALUACION DEL DESEMPEÑO
El poder valorar el desempeño de un sistema de cómputo es necesario en diferentes escenarios,

por ejemplo, para tomar decisiones. Podríamos querer determinar si un sistema existente es apto
o cumple los requerimientos, en cuanto a potencia de cómputo, para una aplicación específica.
Podríamos, también querer determinar si se requiere actualizar o ampliar sus capacidades. A
nivel de diseño o de actualización de un sistema, es importante poder predecir el rendimiento
que tendrá el resultado final y así poder determinar si éste será adecuado para el objetivo
previsto. De este análisis se podrán tomar decisiones acerca de la vialidad del proyecto. Así
mismo, es indispensable poder comparar rendimientos de diferentes opciones al momento de
seleccionar el mejor sistema de cómputo. Asimismo, la evaluación del desempeño nos permite
analizar el rendimiento de un sistema y tomar acciones para su perfeccionamiento.
Para poder evaluar el desempeño de un computador y así poder compararlo respecto a otro
necesitamos poder definir y medir su rendimiento. Pero, ¿Qué queremos decir con
rendimiento?, ¿En base a qué parámetros podemos expresar o medir el rendimiento?, ¿Cómo
podemos establecer un mecanismo que permita comparar dos computadoras? En esta unidad
daremos respuesta a estas preguntas y definiremos un marco conceptual que nos habilite, en
términos generales, para evaluar el desempeño de los equipos de cómputo.
Para poder cuantificar el rendimiento, necesitamos determinar los atributos, características o

factores que influyen en el desempeño del equipo de cómputo e identificar cuál de estos son
determinantes en el desempeño. Estos factores, por tanto, deben ser medibles, directa o
indirectamente. Es decir, deben representar magnitudes. Se denomina medida al valor de una
magnitud obtenido mediante un instrumento de medición confiable. Se denomina métrica al
método de medición (y comúnmente la unidad y la escala) de una medida que se considera
estándar para definir el desempeño de un sistema. En muchos casos, pueden existir diferentes
medidas de interés que pueden usarse para determinar el rendimiento en diferentes escenarios.
A manera de ejemplo, veamos algunas medidas de rendimiento de ciertos aviones:
Tabla 1.1. Cuadro comparativo de características de algunos aviones.
Capacidad Alcance Velocidad Productividad

Aeroplano [Pasajeros] [Millas] [M.p.h.] [Pasajeros X Mph]
Boeing 737 - 100 101 630 598 60,398

Boeing 747 470 4,150 610 286,700
BAC/Sub Concord 132 4,000 1,350 178,200
Douglas DC-8-50 146 8,720 544 79,424
Página 1
De esta tabla podemos concluir que el avión con más velocidad es el Concord, el de mayor
alcance es el Douglas DC-8 y que el Boeing 747 es el de mayor capacidad. Así, por ejemplo,
para un pasajero adinerado que quiere transportarse de un lugar a otro distanciado 4,000 millas
del primero, el Concord es el más rápido. Pero si queremos movilizar 450 personas de una zona
a otra distante las mismas 4,000 millas, entonces, el más rápido es el Boeing 747.
De manera análoga, el desempeño de un computador puede tener diferentes medidas de elección

para diferentes usuarios. Para un usuario individual que está ejecutando un único programa, la
computadora con mayor rendimiento es aquella que complete la ejecución de su programa en
menor tiempo. Sin embargo, para el administrador de un centro de cómputos, que tiene
múltiples tareas que realizar a la vez, la de mayor rendimiento es la que le realice más tareas en
menor tiempo. Como elemento común, sin embargo, se evidencia que la medida del
rendimiento del computador es el tiempo. La computadora que ejecute los programas en menor
tiempo es la que tiene mejor rendimiento.
1.1.1 Medida de rendimiento
La medida del rendimiento de interés en la computadora es el tiempo. Sin embargo,

podemos identificar diferentes medidas de tiempo. Por ejemplo, el tiempo de ejecución de
programas por parte del CPU, puede descomponerse en tiempos de usuario (en que ejecuta los
programas de los usuarios) y el tiempo de sistema operativo. También podemos identificar otros
tiempos que están ligados con los otros componentes del sistema de cómputo: el tiempo
requerido para realizar intercambio de datos con la memoria o con diferentes dispositivos de
entrada-salida que tienen muy diversas velocidades.
Dadas las diferencias e inexactitudes que considerar todos los tiempos posibles puede acarrear,
se toma como la medida de rendimiento más adecuada del computador al tiempo de ejecución
t de un programa por parte del CPU.
1.1.2 Métricas de desempeño
Para poder evaluar el desempeño de un sistema de cómputo y poder comparar dos

sistemas en función de su rendimiento, necesitamos establecer métricas que nos permitan
estandarizar las medidas que emplearemos para tales fines. Las métricas establecen un criterio
estandarizado para evaluar el desempeño de un sistema de cómputo de forma general, de
manera que mediante la medida de tal métrica podamos comparar dos sistemas disímiles.
Todas las métricas de desempeño están basadas en el comportamiento del sistema durante el
tiempo, dado que el tiempo es la medida básica de rendimiento. Existen tres clases de métricas
que pueden denominarse externas, pues pueden percibirse por un usuario o entidad externa al
sistema medido:
• Latencia o tiempo de respuesta.

• Productividad
• Disponibilidad
Página 2
Existe una cuarta métrica de tipo interna o que se percibe desde dentro del sistema. Es la
métrica de utilización. Esta última es de vital importancia para entender el sistema y predecir
su desempeño en condiciones específicas.
La latencia es una medida del tiempo (t) que el sistema tarda en producir resultados. Esta
métrica puede representar diferentes conceptos en dependencia del contexto, por ejemplo, en la
evaluación del desempeño del CPU, tenemos los ciclos de reloj requeridos para completar un
programa, el ancho del pulso o período del reloj del CPU y el tiempo total de ejecución de un
programa; en cambio, en la evaluación del rendimiento de la memoria, tenemos, por ejemplo,
el tiempo de acceso a una celda.
La productividad o throughput () como métrica de rendimiento, es la cantidad de trabajos o

tareas completadas por unidad de tiempo. A diferencia del tiempo de ejecución que mide
directamente el rendimiento del CPU, la productividad depende de diferentes factores externos
y circunstanciales (acceso a disco, algoritmo de scheduling, entre otros) y mide un rendimiento
más global del sistema.
La disponibilidad (d) mide cuánto tiempo un sistema se mantiene en operación normal del
tiempo total requerido.
La utilización () es el fragmento de tiempo que un componente del sistema (CPU, disco,
memoria, etc.) está activo para su utilización o contribuye al trabajo. La utilización se tasa en
el rango entre 0 y 1 o como porcentaje. La productividad máxima de un sistema se alcanza
cuando el componente más ocupado logra una utilización de 1 ó 100%.
Aunque las métricas nos permiten contar con un criterio de comparación genérico, muchas
veces es difícil definir métricas que sean efectivas 100% o estén libres de errores en los
procedimientos o casos de aplicación.
1.1.3 Consideraciones de efectividad-costo
En la evaluación de computadoras, sobre todo con fines económicos o financieros, también se

incluye consideraciones de costos. Normalmente interesa el costo de producción o adquisición,
la tasa de retorno de la inversión (ROI) y el costo total de pertenencia (TCO).
La historia muestra proyectos costosos, como Cray, donde se busca a ultranza lograr el mayor
poder de cálculo con el mejor rendimiento. En estos casos, el costo no se consideró como una
métrica de decisión para la implementación del proyecto. En el otro extremo tenemos a los
proyectos de soluciones SOHO genéricos, donde el menor precio posible es la meta. Aunque el
rendimiento sí cuenta, se puede renunciar a ciertos beneficios en función de obtener un equipo
de bajo costo para un mercado con baja exigencia.
Quizás el mayor trabajo para el arquitecto o diseñador consiste en alcanzar el mayor

rendimiento posible al menor costo.
Página 3
Aunque en este curso nos limitaremos a la evaluación del desempeño más que a la
determinación de costos y su contrastación con los beneficios, sí haremos énfasis, en donde sea
pertinente, en aquellas técnicas que permitan aminorar el costo de los sistemas sin sacrificar la
eficiencia.
1.1.4 Técnicas de análisis de desempeño
Las técnicas de análisis del desempeño de la ejecución de computadoras se pueden clasificar en

cuatro grandes bloques:
• Medición del desempeño (benchmarking)

• Modelado analítico
• Modelado por simulación
• Modelado híbrido
Las técnicas analíticas y de simulación, requieren la construcción de un modelo: una

representación abstracta del sistema real. Un modelo analítico de la ejecución es una estructura
matemática, mientras que un modelo por simulación requiere del soporte de un programa de
computadora especializado.
La mayor parte del arte en análisis de la ejecución queda en seleccionar a un buen modelo que
integre los aspectos más sobresalientes del sistema, eliminando toda la masa de detalles no
pertinentes que puedan ocultar lo esencial del mismo.
La tercera técnica, medida de la ejecución, no usa modelos, pero en cambio se sustenta en la

observación directa y en la recolección de valores del sistema de interés, o un sistema similar.
Esta técnica incluye la elección de métricas y sus medidas a emplear para caracterizar el sistema
y el uso de benchmarks o programas que sirvan como carga de trabajo e instrumento de
medición.
Ninguna técnica es mejor en todos los casos. Los modelos analíticos y de simulación
predominan en escenarios donde no contamos con el sistema utilizable o un prototipo del
mismo. Cuando queremos determinar el desempeño de un sistema existente, la técnica de
medición de la ejecución es lo más indicado.
En nuestro curso emplearemos, sobre todo, métodos analíticos muy simples y genéricos
partiendo desde la óptica del diseñador que pretende lograr un mejor desempeño de un sistema
proyectado más que desde la óptica de evaluar un sistema existente.
1.1.5 Rendimiento:
Dado que la medida de rendimiento es el tiempo, y que a menor tiempo de ejecución

tenemos mayor rendimiento, es decir, el Rendimiento (R) de una computadora es inversamente
proporcional al tiempo de ejecución (t) de la misma, para una carga definida. Por tanto,
podemos definir rendimiento como:
Página 4
1
𝑅 =
𝑡
Con esta medida ya podemos comparar dos computadoras. Sean Ra el rendimiento de la primera
y Rb el de la segunda, para una misma carga, podemos decir que:
Ra > Rb  1 > 1  ty > ta

ta tb
Y podemos cuantificar la relación entre ellas: qué tanto más rinde A sobre B con la razón
siguiente:
Ra
=n
Rb
Donde n es cantidad de veces que A tiene mayor rendimiento que B. En dependencia del
contexto, n se conoce como ganancia “G” (si A es un reemplazo de B) o como aceleración
(A) o mejora de rendimiento (si A es una evolución o actualización de B).
Por ejemplo, si una máquina A ejecuta un programa en 10s y una máquina B en 15s. ¿Qué tanto
mayor es el rendimiento de la máquina A sobre el de la máquina B?
n = tb / ta = 15 s / 10 s = 1.5
– El rendimiento de A es 1,5 veces el de B.
Esta razón es adecuada como base de comparación respecto a la unidad, sin embargo, a veces
queremos saber en cuánto supera una a la otra, es decir, el incremento neto de rendimiento:
n’ = n – 1
O mejor aún, en qué porcentaje la una supera a la otra:
n% = ( n – 1) * 100%
Así el incremento porcentual del rendimiento de X sobre Y, puede expresarse como:
Rx - Ry
n% = * 100%
Ry
Página 5
De donde podemos deducir que A es 50% más rápida que B. Queda como tarea al lector
interesado demostrarlo.
Una vez definida una metodología para comparar rendimientos de dos computadoras mediante
su tiempo de ejecución, es importante definir qué métricas o características básicas intervienen
en la definición de esta medida.
1.1.6 Factores que determinan el tiempo de ejecución
Los factores que inciden en el tiempo de ejecución de un programa son: la frecuencia f

del procesador y la cantidad de ciclos c que transcurren desde que el programa inicia hasta que
concluye, puesto que si podemos determinar ambas podremos determinar el tiempo de
ejecución.
La frecuencia define el ancho del pulso o período de reloj. Cabe mencionar que este período se
define en tiempo de diseño para ser suficientemente ancho a fin de permitir que todas las
operaciones de control requeridas por cualquier paso de control puedan realizarse sin problemas
en ese intervalo de tiempo. Así:
f = 1/
y t  t=c*
Donde la constante c representa el total de ciclos de reloj que se requirió para ejecutar el
programa.
Con estas nuevas relaciones, podríamos obtener información para comparar dos computadoras
en función de su frecuencia. Por ejemplo, suponga que la máquina A ejecuta un programa p en
10s y su CPU tiene una frecuencia de reloj de 100MHz. Usted está diseñando una máquina B y
quiere que ésta ejecute p en solamente 6 segundos, aunque sabe que para ello requiere una
mayor frecuencia de reloj y como consecuencia, serán requeridos 20% más de ciclos para
completar p. ¿Qué frecuencia debe tener B para lograr este objetivo?
ta = ca / fa  ca = ta * fa
cb = 1.2 * ca = 1.2 * ta * fa
fb = cb / tb = (1.2 * ta * fa) / tb
fb = (1.2 * 10s * 100MHz) / 6s = 200 MHz
1.1.7 Ley de Amdahl
Hemos obtenido expresiones que nos permiten relacionar el rendimiento de dos

máquinas. Cuando el rendimiento de una es mayor que el de la otra como efecto de introducir
una mejora, decimos que tenemos una aceleración de rendimiento. Es importante recalcar,
Página 6
sin embargo, que la aceleración global del sistema estará limitada por la fracción de tiempo en
que dicha mejora es efectiva. Es decir, no podemos esperar que el sistema global acelere al
doble si la mejora, que incrementa el rendimiento al doble, solo es capaz de funcionar cierto
porcentaje de tiempo.
Por ejemplo, supongamos que aumentamos la frecuencia de un CPU al doble, podría esperarse
reducir el tiempo de ejecución global a la mitad. Sin embargo, si en cada ciclo de instrucción
se pierde mucho accediendo datos de la memoria, la mejora global alcanzada no será del doble,
sino menor.
La ley de Amdahl nos permite cuantificar la aceleración global neta de un sistema donde se ha
introducido una mejora que es efectiva solo una fracción de tiempo de trabajo del sistema, es
decir, nos permite cuantificar el rendimiento en función de la utilización:
“La aceleración de rendimiento global neta obtenida de incorporar una mejora a un

sistema equivale a la razón entre el rendimiento del sistema al ejecutar una tarea
completa con la mejora, empleando esta todo el tiempo posible, sobre el rendimiento
del mismo al ejecutar la misma tarea sin la mejora, por cuanto el efecto neto de la mejora
está limitado por la fracción de tiempo en que ésta se puede usar”
Ag = Rmejorado / Roriginal = toriginal / tcon mejora
Siendo tg el nuevo tiempo de ejecución global del sistema al incorporar la mejora, t el tiempo
de ejecución original sin mejora, n la ganancia o aceleración parcial que la mejora proporciona,
y , la fracción mejorada (utilización) o el porcentaje de tiempo real que la mejora es efectiva,
entonces:
tg = ttramo en que la mejora es efectiva + ttramo sin mejora
t  
tg = *  + t * (1 −  ) = t * (1 −  ) + 
n  n
y:
t 1
Ag = =
tmejorado 
(1 −  ) +
n
Así, por ejemplo, si una máquina se mejora duplicando la frecuencia del CPU, pero la mejora
solo es efectiva durante el 60% del ciclo de instrucción por el acceso a memoria, la aceleración
global del sistema sería:
Ag = 1 / 0.4 + (0.6/2) = 1/ 0.7 = 1.43
Página 7
Nota  = 0.6 y n = 2
La ley de Amdahl nos conduce a un importante principio de diseño: Acelerar el caso común.
1.1.8 Cálculo del tiempo de Ejecución
Hemos determinado que el tiempo de ejecución depende netamente del total de ciclos
requeridos para ejecutar el programa por el período o duración del ciclo. Ahora analizaremos
más a fondo cómo obtener el total de ciclos del programa. Sabemos que en definitiva, un
programa es una serie de instrucciones a ejecutar. Cada una de estas instrucciones consume una
cantidad de ciclos para completarse, por tanto, la cantidad total de ciclos que emplea una
máquina para ejecutar un programa depende de la cantidad total de instrucciones que se
ejecutan:
N
t =  *  Ci
i =1
Donde ci es la cantidad de ciclos de la i-ésima instrucción, y N es el total de instrucciones

ejecutadas en el programa. Si analizamos bien el programa, determinamos que existen grupos
de instrucciones que consumen la misma cantidad de ciclos de reloj, y por tanto, podemos
detallar el factor sumatoria de la expresión anterior como:
g
t = *cj *nj
j =1
Donde nj representa la cantidad de instrucciones del j-ésimo grupo y cj es la cantidad de ciclos

de reloj que requiere una instrucción del j-ésimo grupo para ejecutarse.
Sabemos del diseño del conjunto de instrucciones que en algunas arquitecturas, todas las
instrucciones tienen la misma cantidad de ciclos de reloj. En este caso, la ecuación anterior
tendría un solo grupo donde el factor “c1” se convierte en una constante a la que llamaremos
CPI (siglas de Ciclos Por Instrucción) y el factor “n1” en el total de instrucciones N.
En algunas arquitecturas, incluso es permisible hacer:
c i
CPI = i =1
I
Página 8
Siendo ci la cantidad de ciclos de la instrucción i-ésima del conjunto de instrucciones I de la

arquitectura en cuestión. Es decir, se utiliza como CPI el promedio de ciclos de las
instrucciones.
Al contar con un CPI constante, entonces el tiempo de ejecución “t” se puede definir como:
CPI * N
t =  * CPI * N =
f
Donde CPI es la cantidad de ciclos por instrucción, N es el total de instrucciones ejecutadas, 

es el período de reloj y f es la frecuencia.
1.1.9 Métricas populares de rendimiento
Se han propuesto una serie de indicadores de rendimiento populares en el intento de crear

una métrica estándar de rendimiento que nos permita comparar dos computadores cualesquiera.
Este es un esfuerzo enorme porque la meta es ambiciosa y difícil de alcanzar. Y aunque, como
resultado de los mismos se han definido una serie de métricas simples que se han empleado
ampliamente, éstas tienen un contexto de aplicación limitado y son susceptibles a errores de
utilización.
1.1.9.1 MIPS
Una métrica muy difundida es la “velocidad o frecuencia de ejecución de instrucciones” que es

una métrica del tipo productividad que normalmente se expresa en millones de instrucciones
por segundo o MIPS. En términos del tiempo de ejecución, la velocidad de ejecución de
instrucciones equivale a la cantidad total de instrucciones ejecutadas sobre el tiempo total de
ejecución. Se emplea el múltiplo millones (dividiendo entre 10 elevado la potencia 6) para
obtener el resultado en un número más legible.
N f
MIPS = 6
=
t *10 CPI *10 6
Como MIPS es una frecuencia, expresa el rendimiento en proporción inversa al tiempo lo cual
es adecuado porque mayores MIPS indican máquinas más rápidas.
El problema con el uso de MIPS consiste en que, si se emplea como método comparativo, debe
tenerse cuidado que las máquinas tengan características similares. Por ejemplo, un programa
que emplea emulación de las operaciones de punto flotante puede resultar con más MIPS que
una máquina que emplea una FPU aunque el tiempo de ejecución del programa sea menor en
la segunda, con lo cual el criterio MIPS nos conduce a un resultado equivocado. De manera
Página 9
similar, si el repertorio de instrucciones de ambas máquinas difiere, es posible que el resultado

también sea equivocado.
1.1.9.2 MIPS relativos
Para atacar el problema de dos máquinas con repertorios muy diferentes, se propuso emplear la
métrica MIPS relativos que se refiere a los MIPS de esta máquina en comparación con una
máquina de referencia. Se medía el tiempo de ejecución de un programa de prueba en la
máquina a evaluar y se dividía entre el tiempo de ejecución del mismo programa en la máquina
de referencia y finalmente se multiplicaba por los MIPS de la máquina de referencia, lo que nos
permitiría comparar dos máquinas respecto a una tercera.
treferencia
MIPS Re lativos = * MIPS referencia
tevaluando
Nuevamente los problemas de esta métrica son que evalúa el desempeño sólo para ese programa
específico, puesto que se han demostrado resultados equívocos con otro tipo de programas.
Adicionalmente, la dificultad de obtener una máquina de referencia adecuada con la misma
carga de los sistemas operativos y compiladores hace casi impráctico este método hoy día.
1.1.9.3 MFLOPS
Para atacar las deficiencias de MIPS, respecto a las diferencias en las operaciones de punto
flotante, que son extensivamente usados en los ámbitos de computación científica, se propuso
emplear los MFLOPS o Millones de Operaciones en Punto Flotante por segundo. Los
megaflops se obtienen del cociente entre el total de operaciones en punto flotante de un
programa sobre el tiempo de ejecución por un millón (para expresar el resultado en megas):
O punto_ flo tan te

MFLOPS =
t *10 6
Aunque está restringido a las operaciones en punto flotante, los MFLOPS son más consistentes
que los MIPS por cuanto la cantidad de operaciones no cambia de máquina a máquina. La
problemática que se presenta, sin embargo, es que los conjuntos de operaciones en punto
flotante disponibles de máquina a máquina no son estándares y por tanto algunas operaciones
se deben implementar en función de otras. Adicionalmente existen operaciones en punto
flotante que son muy rápidas y otras muy lentas.
1.1.9.4 MFLOPS Normalizados
Para la solución a los problemas de MFLOPS se ha propuesto el uso de los MFLOPS

Normalizados. Este método concede pesos relativos a cada tipo de operación en punto flotante
y permite además considerar las operaciones enteras. Al asignar pesos mayores a las
Página 10
operaciones complejas se puede “normalizar” la diferencia de velocidades permitiendo

comparar de manera más equitativa de dos máquinas.
MFLOPSnormalizados =  O * peso _ relativo

i i
t *106
El problema de MFLOPS normalizados, consiste en que evalúa el rendimiento para ese

programa tipo de prueba (benchmark) específico y que, aunque representa una opción para
comparar dos computadoras, no representa el rendimiento de la máquina.
1.1.9.5 Elección de programas de prueba o benchmarks
Para poder determinar los valores o medidas para evaluar una computadora según tal o cual
métrica, se necesita establecer una carga de trabajo idónea. Esta carga de trabajo está compuesta
por uno o más programas tipo que permiten establecer una marca o benchmark de comparación
de esta computadora con otras. La elección de estos programas debe hacerse de forma cuidadosa
de acuerdo a la actividad para la que está pensada la computadora.
Existen cuatro tipos de Benchmarks de acuerdo a las tendencias que se han venido imponiendo:
1. Aplicaciones o Programas reales: Consiste en usar de carga de trabajo la aplicación

principal a emplear en el equipo específico o programas tipo predefinidos como:
Compiladores (GNU C), Procesadores de Texto (Tex) y Aplicaciones CAD (Spice).
2. Núcleos o Kernels: Emplea extracciones de secciones de código importante de

programas reales usadas para evaluar rendimiento, por ejemplo, Livermore Loop y
LinPack.
3. BechMarks Reducidos o Toys: Emplean rutinas pequeñas (10–100 líneas) con

resultados conocidos. Se introducen y ejecutan fácilmente en computadores para medir
su desempeño. Ejemplo: QuickSort, Puzzle.
4. BechMarks Sintéticos: Análogos a la filosofía de los Núcleos. Se crean mezclas de

diferentes rutinas de programas reales o inventados por el diseñador del benchmark.
Determinan frecuencia media de operaciones y acceso a operandos en diferentes
escenarios de cómputo. No calculan algo que un usuario pueda utilizar solo pretende
determinar un perfil medio de ejecución que sirva de referencia para comparar con otras
máquinas. Ejemplos de éstos son: WhetStone y Dhrystone.
Página 11
1.2 REDUCCIÓN DEL TIEMPO DE EJECUCIÓN
Hemos determinado de qué factores depende el tiempo de ejecución, de manera que si

queremos reducirlo, habrá que reducir aquellos factores que inciden en proporción directa en el
tiempo de ejecución o incrementar los que lo hacen en proporción inversa. Como es de
esperarse, la interrelación entre los mismos o las limitaciones físicas o tecnológicas frenarán la
máxima aceleración o mejora que pueda alcanzarse.
1.2.1 Reducción del período de reloj.
La primera apuesta y la más obvia apunta a reducir el período de reloj . Para lograr este
cometido, sin embargo, puede ser necesario reimplementar la máquina completa por cuanto el
período de reloj se decide en función de la máxima cantidad de pasos de control que se requieren
ejecutar de una sola vez, así como la máxima duración de éstos. Las mejoras realizadas en este
sentido, han implicado reducciones en el grosor de la oblea de silicio con que se fabrican los
procesadores. A menor grosor, menor distancias a recorrer y por tanto menor tiempo de
propagación.
Como ejemplo, la familia Intel x86 ha ido reduciendo significativamente el período de reloj
(aumentando la frecuencia) del CPU:
Tabla 1.2. Frecuencias de CPUs ix86
CPU
f (MHz)  (ns)
Desde Hasta Desde Hasta
8088, 8086 1.7 1.7 588.2 588.2
80186 1.7 4 588.2 250.0
80286 4 12 250.0 83.3
80386 25 33 40.0 30.3
80486 33 100 30.3 10.0
Pentium 66 233 15.2 4.3
Pentium II 266 400 3.8 2.5
Pentium III 450 1,300 2.2 0.8
Pentium 4 1,300 4,000 0.8 0.3
1.2.2 Reducción de la cantidad de instrucciones N.
La segunda línea de acción para reducir el tiempo de ejecución, consiste en reducir la

cantidad de instrucciones de los programas. Durante los 50´s y 60´s, de hecho, prevalecieron
los esfuerzos en este sentido. Los conjuntos de instrucciones se diseñaban cada vez más
complejos de forma que el programador tuviera a disposición diferentes formas de lograr la
misma operación.
Una meta común en estos esfuerzos fue el lograr la mayor ortogonalidad posible a fin que los
programas pudieran ser más compactos al permitir cualquier combinación de operandos en las
instrucciones. Posteriormente se encontró que esta dirección no llevaba a mejoras sustanciales
por cuanto al complejizar las instrucciones fue requerido complejizar el hardware del CPU,
Página 12
sobre todo de la unidad de control. Como consecuencia, fue necesario un período de reloj más
ancho o mayor cantidad de ciclos para ejecutar las instrucciones.
El surgimiento de la microprogramación con la gran flexibilidad de diseño que ésta proporcionó

a los arquitectos, propiciaron la propagación de los conjuntos de instrucciones complejos,
alentada por la asumpción incorrecta que siempre el hardware es más rápido que el software.
Afortunadamente el avance de la tecnología permitió mitigar el impacto de la introducción de
estos conjuntos de instrucciones complejos en el desempeño, al producirse hardware más
rápido.
Posteriormente, el proyecto RISC, determinó que ni los programadores ni los compiladores

estaban sacando todo el provecho a las instrucciones complejas. Adicionalmente, se pudo
comprobar que en muchos casos una sola instrucción compleja dilataba más tiempo en
ejecutarse que varias instrucciones más simples que realizaban la misma operación. Los
hallazgos de RISC proponen que en muchos casos es más eficiente un programa con mayor
cantidad de instrucciones si el hardware del CPU que lo ejecuta puede simplificarse y acelerarse
lo suficiente. Cabe mencionar que al momento que se introdujo RISC, se podía contar con
muchos registros de propósito general en el CPU a bajo costo, lo cual no era posible antes y por
tanto la mayoría sino que todos los operandos residían en memoria principal, imponiendo un
cuello de botella en la ejecución.
1.2.3 Reducción del CPI
Finalmente, también tenemos una importante posibilidad de mejorar el rendimiento al

reducir el CPI por cuanto este es un factor entero que n-plica el tiempo de ejecución. Imagine,
reducir el CPI de 4 a 2, reduciría categóricamente el tiempo de ejecución a la mitad.
La idea común en este sentido apunta a reducir el CPI a su mínima expresión, es decir, a 1.
Obviamente tal propósito requerirá un período de reloj muy ancho así como reducir al máximo
los cuellos de botella (acceso a memoria y entrada-salida).
Como actividad práctica, proponemos identificar qué tan eficiente es el procesador simple
basado en un bus común estudiado en los cursos anteriores. Identificar las limitantes de diseño
que inciden en su desempeño y proponer un diseño mejorado que permita reducir el tiempo de
ejecución.
1.2.4 Consecuencias de la ley de Amdahl
Hemos estudiado los factores de los cuales depende el rendimiento del CPU y cómo
reduciendo estos factores podríamos reducir el tiempo de ejecución. No podemos despreciar las
latencias del acceso a las otras partes de la computadora cuando queremos evaluar la aceleración
o impacto global que reducir el tiempo de ejecución tendrá en todo el sistema.
Puesto que cada instrucción a ejecutarse es llevada desde la memoria al CPU, las latencias en
el acceso a la memoria, limitarán la aceleración global del sistema, pues la aceleración lograda
Página 13
a lo interno del CPU no podrá usarse todo el tiempo sino solo una fracción de éste, según se
evidencia en el ejemplo del acápite 1.1.8. Un caso similar se dará con el acceso a dispositivos
periféricos cuando se requieran datos que deban leerse directamente de un puerto de entrada-
salida.
Por tanto, nuestro estudio de la mejora del rendimiento del ordenador no estaría completo sin
estudiar las mejoras del rendimiento de los otros dos subsistemas que componen la
computadora: la memoria y el sistema de entrada-salida.
1.3 MEJORAS AL SISTEMA DE MEMORIA
La ley de Amdahl expresa que el efecto neto de las mejoras aisladas a una parte del
sistema está limitado por la fracción de tiempo que dicha mejora se pueda emplear. El sistema
de memoria es crítico en la ejecución de los programas por cuanto cada instrucción reside en
memoria y muchos de los operandos también.
De nuestro curso anterior conocemos que el ciclo de máquina de lectura o escritura en memoria
normalmente requiere varios ciclos de reloj, convirtiéndose en un verdadero cuello de botella
en el sistema de ejecución. En este sentido, el diseño del bus del sistema juega un rol muy
importante. En muchos casos, incrementar el ancho del bus puede incrementar
significativamente la velocidad de transferencia. Asimismo, implementar un diseño de
múltiples buses puede reducir cuellos de botella. También se pueden solapar en el tiempo
diferentes ciclos de acceso a memoria mejorando el desempeño global del sistema de memoria.
En este sentido, es evidente que cualquier mejora de velocidad en el acceso a la memoria es

determinante en el rendimiento de la máquina. Existen dos métricas importantes en un sistema
de memoria: el tiempo de acceso y la capacidad. A lo largo del tiempo se observa una tendencia
constante a demandar más y más memoria. Sin embargo, en la medida que crece el tamaño de
la memoria, se requieren más circuitos de decodificación que retardan el acceso a las celdas de
almacenamiento. Adicionalmente, la tecnología de fabricación de la memoria también influye
en el desempeño de la misma. La memoria estática es muy rápida pero mucho más costosa que
la dinámica. Los grandes tamaños de memoria principal, relativamente barata, con que
contamos hoy día solo son posibles gracias a la memoria dinámica.
1.3.1 Jerarquía de memoria
Es evidente que para las tareas de cómputo actuales, incluso en computadores

personales, necesitamos grandes cantidades de memoria principal. Es igualmente evidente que
los costos hacen prohibitivo implementarlas en memoria estática, sino más bien en memoria
dinámica que es varias veces más lenta que la primera. Una solución razonable consiste en
introducir una memoria intermedia estática entre el procesador y la memoria principal que no
sea tan grande y por tanto a precio razonable. A esta memoria intermedia se le conoce como
memoria caché. Para que sea eficiente y eficaz, en ella deben almacenarse sólo los datos e
instrucciones más usados.
Página 14
Este arreglo de memoria intermedia implica una jerarquización del almacenamiento

donde en el más alto nivel tenemos el almacenamiento interno al CPU (registros) pasando por
la caché, continuando con la memoria principal hasta llegar al almacenamiento secundario. En
cada nivel se establecen diferentes valores de velocidad de acceso, capacidad, tecnología y
costo verificándose que a medida que bajamos en la jerarquía disminuye la velocidad de acceso
(o aumenta el tiempo de retardo) y aumenta la capacidad. El modelo, para ser eficiente debe
imponer en lo posible que todo acceso se dé solo entre niveles adyacentes. Se pueden introducir
varios niveles intermedios cada vez más la brecha de rendimiento entre niveles.
1.3.2 Principio de localidad de referencia.
Para que la jerarquía de memoria funcione, las cachés deben tener una utilización
cercana a 100%, pues de lo contrario la aceleración global lograda no justificaría el incremento
costo al introducir una memoria extra bastante cara. Afortunadamente, el principio de localidad
de referencia garantiza la consecución de este objetivo bastante bien.
Este principio se basa en los principios primitivos de la organización de la máquina Von

Neumann de secuencialidad de los programas y de vecindad de almacenamiento. Podemos
decir que el principio tiene dos componentes: uno temporal y el otro espacial. El temporal
predica que una palabra de memoria que se referencia en este momento, tiene gran probabilidad
de reverenciarse en el futuro cercano (debido a la modularidad y ciclos en los programas). De
forma similar, el componente espacial establece que las palabras vecinas de la palabra que se
está referenciando actualmente tienen alta probabilidad de referenciarse en el futuro próximo.
CPU
Registros
Caché
Meo
rV
eloc
ad
acid
id
ad d
C ap
Caché
e Tra
or
Externa
May
n sf e
renc
ia
Memoria Principal
Unidades de almacenamiento secundario
Figura 1.1. Jerarquía de Memoria.
Página 15
1.3.3 Cálculo de la aceleración del rendimiento en la jerarquía de memoria
El cálculo del rendimiento de un sistema jerárquico de memoria con caché es un caso

específico de aplicación de la ley de Amdahl. La utilización de la caché se puede cuantificar
mediante la tasa de aciertos (h) o el porcentaje de veces que una referencia a memoria se
encuentra efectivamente en la caché. La ganancia del sistema o aceleración del rendimiento
del tramo mejorado es la proporción en la cual la velocidad de acceso a la caché supera a la
memoria principal, por ejemplo: si la caché tiene un tiempo de acceso de 10ns y la memoria
principal tiene un tiempo de acceso de 100ns, la ganancia (n) del sistema cuando se puede
acceder a caché es de 10. Así el tiempo de acceso global de un sistema con caché en función
de los tiempos de accesos de sus memorias es:
𝑡𝑔 = 𝑡𝑐 ∗ ℎ + (𝑡𝑐 + 𝑡𝑚 ) ∗ (1 − ℎ)
Siendo tg el tiempo global del sistema, tc el tiempo de acceso de la caché y tm el tiempo de

acceso de memoria principal.
1.4 MEJORAS AL SISTEMA DE ENTRADA-SALIDA
De forma similar al sistema de memoria, en la Entrada/Salida, la brecha de ancho de

banda entre dispositivos de diferentes velocidades de trasferencias se puede reducir mediante
la jerarquización de buses y la anexión de buffers en algunos módulos controladores de
entrada-salida. Además de el equilibrio de ancho de banda, se pueden solapar en el tiempo las
operaciones de transferencia de datos con las operaciones de CPU, mediante la incorporación
de controladores de DMA, canales de E/S y módulos inteligentes de dispositivos.
CPU +
Cache L2
Cache L1
"Bus" AGP Controladores del sistema

Controlador (Chipset) Bus del Sistema Memoria
de vídeo Controlador de Memoria y Principal
Puente PCI
Bus PCI
Dispositivos IDE SCSI LAN Slot
CD DD Controlador IDE
Controlador de DMA USB
DD DD Puente PCI a ISA
Bus ISA
LPT Disquete
Slot Slot
Super
Com 1 Teclado
I/O
Com 2 Ratón PS/2
Figura 1.2. PC con jerarquización de buses de E/S.
Página 16
1.4.1 DMA
Este método de transferencia avanzado, se implementó con el objetivo de mejorar la

velocidad de transferencia de datos, sobre todo para dispositivos y aplicaciones de E/S muy
rápidos (Adquisición de sonido, discos duros de alta velocidad y video). Consiste en proveer
un procesador auxiliar capaz de hacer E/S por programa directamente a la memoria, relevando
al CPU de esta tarea.
DMA se aprovecha cuando los dispositivos son capaces de transferir gran cantidad de datos de
una vez. Surge un problema de concurrencia en el bus del sistema respecto al CPU. Este se
resuelve con Cycle Stealing, que permite al procesador de DMA bloquear al CPU el uso del
bus algunos ciclos a fin de realizar la transferencia de DMA.
Cuando un programa desea realizar una transferencia empleando DMA, el CPU inicializa los
parámetros de la misma e indica al Módulo DMA, acto seguido, el CPU se desentiende de la
transferencia. El procesador de DMA coordina el acceso al dispositivo y sincroniza la
transferencia en función del esquema de sincronización del bus del sistema. El procesador de
DMA y el dispositivo de E/S se sincronizan mediante líneas de control del Procesador de DMA
denominadas canal de DMA.
Una ventaja de DMA sobre interrupciones es que la transferencia en DMA puede hacerse en
cualquier ciclo, en tanto en Interrupciones, la verificación de solicitudes de interrupción se hace
hasta al final de la fase de ejecución.
1.4.2 Procesadores y Canales de E/S
Son una evolución de DMA. Consisten en procesadores inteligentes de tratamiento de

E/S, capaces de atender a múltiples dispositivos a la vez. A diferencia de DMA que empleaba
el bus del Sistema para realizar la transferencia, cuando se usa un IO Processor, IO Channel o
Canal de E/S, los dispositivos se conectan directamente al canal de E/S. Actualmente, los
módulos DMA emplean Procesadores de E/S y pueden ofrecer las mismas características que
ofrecen los canales.
Estos Procesadores de E/S se implementaron en computadoras grandes (Supercomputadoras,

mainframes y en algunas Minicomputadoras) permitiendo jerarquizar el sistema de E/S
reduciendo la brecha de velocidades entre los diferentes dispositivos.
1.5 INTRODUCCIÓN AL PARALELISMO
Debido a la interrelación de los factores que determinan el tiempo de ejecución y a las

limitaciones propias de la arquitectura secuencial, existe una máxima aceleración que se puede
lograr en el tiempo de ejecución. Cuando se requiere mayor desempeño, no queda otro camino
que mejorar la arquitectura introduciendo paralelismo. Por ejemplo, es posible que una persona
no puede ser más rápida en ejecutar una tarea por mucho que se esfuerce, sin embargo, quizás
dos personas sí puedan hacerlo si comparten el trabajo.
Página 17
En computación se ha evidenciado, desde sus inicios, una necesidad y tendencia hacia el

paralelismo:
• Se requiere cada vez más poder de cómputo y además concurrencia (datos compartidos).
• Desde la introducción de las primeras enormes y costosas máquinas se requirió
capacidad de atención a múltiples usuarios para que fueran costo-efectivas.
• Los dominios de aplicación se han ido ampliando cada vez más: desde un procesamiento
de datos se ha pasado a un procesamiento de información, de conocimiento y
últimamente se habla de “inteligencia”.
• Los avances continuos en tecnología de producción de hardware a gran escala facilitan
la producción de sistemas paralelos a menor costo.
1.5.1 Procesamiento paralelo
El procesamiento paralelo es una forma eficaz de procesamiento que favorece la

explotación de los sucesos concurrentes en un sistema de computación. Esta concurrencia
implica simultaneidad, solapamiento y multiplicidad de recursos. El paralelismo que involucra
solapamiento se denomina temporal porque permite la ejecución concurrente de sucesos sobre
los mismos recursos en intervalos intercalados de tiempo. El paralelismo que permite
simultaneidad real sobre múltiples recursos al mismo tiempo se denomina paralelismo espacial.
1.5.2 Diferentes mecanismos y técnicas de mejora del desempeño empleadas
A medida que se fueron evidenciando las necesidades y requerimientos de mayor poder

de cómputo y rendimiento en los sistemas se fueron implementando una serie de técnicas y
mecanismos de mejora del desempeño que introducen algún nivel de paralelismo que han ido
evolucionando y consolidándose permitiendo los niveles de rendimiento que tenemos en las
computadoras hoy día:
1.5.2.1 Multiprogramación y tiempo compartido.
Esta es una técnica de software introducida por los diseñadores de sistemas operativos para
implementar paralelismo temporal en la ejecución de múltiples procesos de usuarios y los
mismos procesos del sistema operativo, logrando que todos progresen a la vez. La
multiprogramación permite tener múltiples procesos en memoria y sólo realiza cambio de
contexto con los procesos de house keeping del sistema o cuando el proceso se bloquea en
espera de un servicio. El tiempo compartido es más dinámico en el sentido que asigna un
quantum de tiempo de CPU a cada proceso.
1.5.2.2 Solapamiento de las operaciones CPU y E/S.
Mecanismos de mejora del sistema de entrada/salida que permite liberar al CPU de las
operaciones de entrada–salida, permitiéndole ejecutar otras operaciones. Este mecanismo
requiere la introducción de procesadores auxiliares para la transferencia de entrada–salida a
Memoria: controlador DMA, Canales de E/S y controladores de E/S inteligentes.
Página 18
1.5.2.3 Jerarquización y equilibrio de ancho de banda.
Las diferencias de velocidad entre diferentes componentes del sistema afectan el desempeño
global del mismo por los cuellos de botella que los dispositivos más lentos imponen en las
transferencias entre ellos. La jerarquización de diferentes niveles y la introducción de niveles
intermedios que reduzcan la brecha de velocidad, permite ir equilibrando el ancho de banda del
sistema y acelerar su rendimiento global. En el sistema de memoria contamos con la jerarquía
de memoria y en los sistemas de entrada salida con técnicas de compensación con la
jerarquización de buses y técnicas de buffering en los módulos de entrada/salida.
1.5.2.4 Solapamiento de la ejecución y Segmentación encauzada.
El modelo de ejecución de las máquinas secuenciales puede ser ineficiente en cuanto al nivel
de utilización de los componentes internos del CPU, al ocupar todos los recursos en el ciclo de
instrucciones completo. Un análisis de las fases y etapas del ciclo nos permiten identificar
diferentes tareas que podrían solaparse. Por ejemplo, la fase fetch solo se encarga de traer la
próxima instrucción. Finalizada la fase fetch, el PC no vuelve a utilizarse hasta la próxima fase
fetch. Entonces, podría considerarse que cuando se complete la traída de la instrucción i, una
parte dedicada del CPU puede ir a traer la siguiente instrucción i+1, mientras el resto ejecuta la
instrucción i.
Cada parte o sección del CPU se denomina en este caso etapa o segmento del cauce de ejecución
o pipeline, porque la salida de cada etapa anterior alimenta la entrada de la siguiente como si
estuvieran conectados en una tubería. Por eso la implementación de tal solapamiento de la
ejecución en el CPU se denomina segmentación encauzada. El ejemplo de segmentación
mostrado en este párrafo solo consta de dos etapas y se le conoce como precarga de
instrucciones (prefetching), sin embargo, los sistemas segmentados hoy día suelen tener muchas
más etapas de cauce.
La técnica de solapamiento de la ejecución, permite reducir considerablemente el tiempo de

ejecución, como lo estudiaremos en la unidad 2.
Adicionalmente, los sistemas de acceso a memoria también han implementado un modelo de

solapamiento en los ciclos de máquina de acceso a memoria, permitiendo reducir grandemente
el tiempo de respuesta global del sistema.
Página 19
Suma
Banco de Multiplic. 1
Registros
Multiplic. 2
(24 x 32)
División
Suma Fija
Incremento
Subsistema de Entrada
Memoria Central
/ Salida Decremento
Lóg ica
Desplazamiento
Bifurcación
Pila de
Instrucciones
Marcador
Figura 1.3. Multiplicidad de unidades funcionales en le CDC-6600
1.5.2.5 Sistemas escalares o multiplicidad de unidad funcionales
La introducción de la segmentación de bajo nivel o prefetching de instrucciones,

condujo a otra mejora en rendimiento que consiste en agregar más de una unidad aritmética al
procesador a fin de poder acelerar aún más la ejecución. Con esta importante mejora de diseño,
podrían tenerse más de una instrucción en ejecución a la vez. Este modelo, sin embargo
introduce requerimientos nuevos también en cuanto a mantener el orden estricto de ejecución
de las instrucciones y el control de disponibilidad de los recursos. A los sistemas que
implementan esta mejora se les conoce como sistemas escalares. Por ejemplo, la CDC-6600
que se muestra en la figura 1.3, emplea una cola de instrucciones y 10 unidades aritméticas
además de un marcador o scoreboard para registrar y controlar la disponibilidad de las unidades
funcionales y los registros.
1.5.2.6 Sistemas paralelos.
Las técnicas mencionadas arriba, explotan mayormente el paralelismo temporal. Algunas

introducen elementos de paralelismo espacial al incorporar elementos auxiliares de proceso o
varias unidades funcionales. Aunque los sistemas escalares introducen un nivel interesante de
paralelismo espacial, suele denominarse “sistemas paralelos” solamente a aquellos que explotan
el paralelismo efectivamente mediante la multiplicidad de procesadores o elementos de
procesamiento simples o complejos que colaboran en la solución de uno o más problemas de
forma simultánea.
Existen varios tipos y arquitecturas que estudiaremos a lo largo de la unidad 3 y 4.
1.6 CLASIFICACIÓN DE LAS ARQUITECTURAS PARALELAS.
Página 20
Se han propuesto diferentes criterios para clasificar las arquitecturas paralelas, según diferentes
características y niveles de paralelismo. De entre estas resaltan las de Flynn, Feng, Handler,
Hockney - Jesshope y Shore.
1.6.1.1 Taxonomía de Flynn
Flynn propone establecer categorías de clasificación en función de la multiplicidad de los

flujos de datos y de instrucciones que se conjugan en la ejecución de estos sistemas.
Considerando que un flujo puede ser simple o múltiple, establece cuatro categorías posibles:
• SISD (Simple flujo de Instrucciones - Simple flujo de Datos)
Esta categoría incluye a todos los sistemas de un solo CPU. Las ejecuciones se ejecutan
de forma secuencial, pero puede haber segmentación.
Ejemplos de esta categoría son los computadores viejos IBM 370 e IBM 7090, el VAX
y el Intel 8086.
• SIMD (Simple flujo de Instrucciones - Múltiples flujos de Datos)
Esta categoría incluye una gran diversidad de procesadores paralelos que ejecutan una
misma instrucción sobre un conjunto de datos al unísono o solapadamente. Las
máquinas típicas SIMD son los procesadores matriciales con una red de múltiples
elementos de proceso (EP) supervisados todos por una la misma unidad de control.
Todos los EP reciben la misma instrucción emitida por la unidad de control y operan
esta instrucción sobre los datos residentes en su memoria local. Los miembros de esta
categoría serán nuestro objeto de estudio de la unidad 3.
• MISD (Múltiples flujos de Instrucciones - Simple flujo de Datos)
Este modelo propone la existencia de n unidades procesadoras; cada una recibe distintas
instrucciones que operan sobre el mismo flujo de datos. La salida de un procesador pasa
a ser la entrada del siguiente. Muchos autores coinciden en que no existe espécimen
para esta categoría, aunque algunos insisten en considerar las etapas de un cauce como
entidades procesadoras y ubican los sistemas segmentados en esta categoría.
Dado que las etapas no son autónomas, nuestra posición para efectos de este curso será
aceptar y declarar la vacuidad de esta categoría.
• MIMD (Múltiples flujos de Instrucciones - Múltiples flujos de Datos)
Esta categoría incluye a todos los sistemas paralelos que constan de múltiples
procesadores autónomos trabajando cooperativa y coordinadamente en la solución de
uno o más problemas de forma simultánea. Esta categoría nos ocupará durante la unidad
4.
Página 21
2 SEGMENTACION
2.1 INTRODUCCION
La ejecución secuencial de instrucciones es muy lenta. Hemos expuesto que las mejoras
en tiempo de ejecución están limitadas por la interrelación entre las variables de la definición
del tiempo de ejecución secuencial t, que depende del número de instrucciones ejecutadas N, el
número promedio de ciclos de reloj consumidos por cada instrucción CPI y el período de reloj
del CPU,  según muestra la expresión:
t =   N * CPI
¿Existe alguna posibilidad de ejecución para aumentar el rendimiento reduciendo el tiempo de

ejecución? Pues sí: aplicar técnicas de paralelismo. Una de las técnicas de paralelismo más
empleadas por ser implementadas a lo interno del procesador es la segmentación encauzada o
pipelining en lengua inglesa. Se ha anotado que existen dos tipos de segmentación: la lineal y
la no-lineal. La ejecución segmentada de instrucciones es un ejemplo de segmentación lineal,
que será nuestro foco de interés en este capítulo.
La segmentación encauzada es una técnica de implementación que consiste en solapar la

ejecución de múltiples instrucciones en el tiempo. Eso significa que no se requiere esperar hasta
que la i-ésma instrucción concluya para comenzar a ejecutar la i+1-ésima instrucción. Hoy en
día, la segmentación es clave en la implementación de CPUs rápidos. Cabe mencionar que la
segmentación también se emplea en la construcción de unidades aritméticas. La figura 2.1.
muestra la ejecución secuencial que conocemos del curso anterior versus la ejecución solapada
que permite la segmentación.
I1 Ejecución Secuencial
(Se ejecuta una instrucción tras otra)
I2
s1 s2 s3 s4 s5
I1 Ejecución Segmentada
s1 s2 s3 s4 s5 (Se ejecutan instrucciones solapadamente.
I2 El CPU se organiza en secciones o etapas
s1 s2 s3 s4 s5 que encadenadas se denominan cauce.
I3 Una vez que una instrucción completa su
s1 s2 s3 s4 s5 parte de ejecución en una etapa, pasa a la
I4
siguiente y otra nueva instrucción puede
I5 s1 s2 s3 s4 s5 ocupar la que ésta deja libre. Una vez que el
cauce está lleno, se produce una instrucción
s1 s2 s3 s4 s5 por ciclo)
I6
Figura 2.1. Ejecución secuencial frente a la segmentada.
La segmentación es similar a una línea de producción en serie o cadena de ensamblaje: la cadena

se compone de una serie de fases o etapas consecutivas de producción que son necesarias para
Página 22
completar el producto o tarea. El producto se construye con diferentes piezas o partes que se
ensamblan en cada etapa de la cadena. Cada etapa cuenta con el equipamiento requerido para
completar la subtarea que le compete. En cada etapa de la cadena se ensambla una parte o pieza
y al final de la misma tenemos el producto completo. La gran ventaja es que no se necesita
esperar a que un producto completo esté listo para comenzar a ensamblar el siguiente, sino que
apenas una etapa completa su parte del trabajo, la pasa a la siguiente y comienza a procesar su
parte correspondiente del siguiente trabajo.
Análogamente, en la segmentación encauzada, la ejecución de una instrucción se divide en

diferentes fases y el procesador se organiza en unidades o secciones de ejecución relativamente
independientes llamadas segmento o etapa. Cada etapa de la segmentación completa o ejecuta
una parte de la instrucción. La CPU segmentada trabaja entonces como una línea de producción
en serie: La primera etapa carga la primera instrucción y completa su primera fase. Una vez que
esta fase ha terminado, pasa su salida a la siguiente etapa y toma la segunda instrucción mientras
la segunda etapa ejecuta la segunda fase de la primera instrucción. Este procedimiento se repite
entre las restantes etapas. Cuando la primera instrucción sale de la última etapa, su ejecución
está completa. En el siguiente pulso de reloj saldrá la segunda del cauce y así en lo sucesivo.
La figura 2.2. muestra el diagrama a bloques cómo se estructura un cauce de instrucciones que
opera según lo descrito. Cada etapa, en el gráfico se representa con un bloque verde. Los
bloquecitos celestes representan latches o registros de retención que tienenla misión de separar
los datos entre etapas, para evitar sobreposición de los mismos, según se explicará
posteriormente.
Input S1 S2 S3 S4 S5 Output
Clock
Figura 2.2. Diagrama de bloques de un cauce de Instrucciones.
Como todas las etapas están conectadas entre sí, todas ellas deben estar listas para proceder al
mismo tiempo; es decir, deben estar sincronizadas. El tiempo requerido para desplazar una
instrucción, un paso a lo largo del pipeline normalmente se hace corresponder a un ciclo del
reloj del procesador (). La duración de un ciclo máquina, está determinada por el tiempo que
necesita la etapa más lenta, porque todas las etapas deben progresar a la vez. El diseñador debe
entonces, equilibrar la duración de las etapas de la segmentación. Si las etapas están
perfectamente equilibradas, el ciclo de la máquina segmentada es óptimo porque reduce el gasto
por segmentación.
El objetivo de la segmentación es conseguir una instrucción por ciclo, aunque cada instrucción
por separado ocupe varios ciclos (CPI > 1). La productividad de la segmentación está
determinada por la frecuencia con que una instrucción salga del cauce. La segmentación
incrementa la productividad de instrucciones de la CPU porque el número de instrucciones
completadas por unidad de tiempo se incrementa, aunque no reduce el tiempo de ejecución de
cada instrucción debido al gasto en el control de la segmentación. El incremento en la
Página 23
productividad de instrucciones significa que un programa corre más rápido y tiene menor
tiempo total de ejecución aun cuando ninguna instrucción se ejecute con más rapidez.
El cauce de instrucciones mostrado en la figura 2.2. es un cauce lineal porque todas las etapas
tienen una relación de precedencia lineal entre ellas. El cauce lineal obliga a todas las
instrucciones a atravesar todas y cada una de las etapas del mismo, aunque no la necesite y por
tanto todas las instrucciones duran igual tiempo.
La precedencia está definida como una relación en el conjunto de subtareas en las que se divide
la tarea global que ejecuta el encauzado y define el orden de ejecución de las mismas:
Sea una tarea T, definida como el conjunto de subtareas requeridas para completarse:
T = {T1, T2, ...., Tk}
Si se verifica que la subtarea Tj no inicia hasta completar Ti  i < j y que una subtarea solo se
ejecuta una vez, entonces las subtareas tienen entre sí una relación de precedencia lineal. Si las
subtareas pueden ejecutarse en diferente orden y/o repetidamente, se tiene una relación no lineal
de precedencia y se dice que el cauce es no lineal o general.
Un cauce puede representarse en forma de diagrama de bloques como la figura 2.2 o como un
grafo de precedencia donde se muestre la relación entre las subtareas.
El funcionamiento de un cauce de instrucciones puede modelarse mediante diagramas de

instrucciones o diagramas espacio-tiempo. El primero muestra el solapamiento de las
instrucciones en el tiempo y el segundo la utilización del cauce.
Espacio
Diagrama de Instrucciones Diagrama Espacio/tiempo
S4 T 14 T 24 T 34 ...
T 44 T 54
inst i
inst i+1 S3 T 13 T 23 T 33 T T4
3
... 5
3
inst i+2
S2 T 12 T 22 T 32 T 42 T ...
5
2
inst i+3
S1 T 11 T 21 T 31 T 41 T 51 ...
inst i+4
Tiempo
1 2 3 4 5 6 7 8 (ciclos)
Figura 2.3. Diagramas de Instrucciones y Espacio-Tiempo.
El diagrama Espacio-Tiempo, introducido por Chen, se conforma por un cuadrante

bidimensional con el Espacio (etapas del cauce) en el eje de las “y” y el tiempo (ciclos de reloj
consumidos) en el eje de las “x”. Cada tramo espacio-tiempo representa la ejecución de la
SubTarea Ti en la etapa j. El subíndice representa la etapa y el superíndice la tarea.
Página 24
2.2 RENDIMIENTO DEL PROCESADOR SEGMENTADO
Hemos establecido que el rendimiento de las computadoras puede determinarse a través de dos
medidas principales: el tiempo de ejecución y la productividad. En un procesador encauzado,
el rendimiento es superior al de un procesador secuencial debido al solapamiento (paralelismo
temporal) en la ejecución. Sabemos que el tiempo de ejecución en un procesador secuencial
es:
t1 = N * CPI * 
Donde el subíndice 1 de t denota que es secuencial, es decir, solo tiene 1 etapa que ejecuta toda
la instrucción de una vez. N son las instrucciones totales ejecutadas y  es el período de reloj.
Procedamos ahora a determinar una expresión para el tiempo de ejecución de un procesador
segmentado de k etapas tk.
El período del reloj de un procesador encauzado depende de la duración de la etapa más lenta,
porque estamos modelando una cadena de producción donde todas las etapas deben proceder al
mismo tiempo. Así el período, para un procesador de k etapas es:
1 r 2 3 4 5
Input S1 S2 S3 S4 S5 Output
Clock
 = Max {  i }1 +  r
k
=  max +  r
Figura 2.3. Cálculo del período de un procesador encauzado..
Como todas las instrucciones duran lo mismo, puesto que deben pasar por todas las etapas del
cauce, y suponiendo que éste requiere un solo ciclo de reloj para ejecutar las operaciones de
cada etapa, entonces el CPI de todas las instrucciones equivale al número de etapas del cauce,
es decir: CPI = k.
El procesador encauzado, requiere k ciclos de reloj para producir la primera instrucción. Una
vez que el cauce está lleno, se produce una instrucción por ciclo, como puede apreciarse en la
figura 2.1. Entonces, podemos definir el tiempo de ejecución como el tiempo requerido para
ejecutar la primera instrucción (k * ) más el tiempo requerido para el resto que no es más N-1
ciclos. Así el tiempo de ejecución segmentado, denotado por tk es:
tk = k *  + (N – 1) * 
Así la ganancia de rendimiento de un procesador segmentado sobre uno secuencial se define
como:
Página 25
t1 N*k
G= =
tk k + ( N -1 )
La máxima ganancia del cauce es el límite de G cuando N → ∞ que es k, por tanto G = k.
La productividad del cauce depende de la eficiencia del mismo, es decir, de la capacidad de

mantenerse lleno, pues es solo con cauce lleno que este logra su objetivo de producir una
instrucción por ciclo. La Eficiencia es, por tanto, una medida de la utilización del cauce. De
forma general, resulta de la razón de tramos espacio-tiempo ocupados sobre el total de tramos
transcurridos durante la evaluación (ver figura 2.3). Más adelante se estudiará que existen
riesgos de control que evitan la utilización total del cauce en todo momento, con lo cual este
cálculo varía.
Nótese que los tramos ocupados durante la primera instrucción se complementan con los tramos
desocupados una vez que la última instrucción entra al cauce, por tanto, el total de tramos llenos
es: N * k *  y el total de tramos es: k *  *[ k + (N -1)]. Así, la eficiencia es:
N*k* N
= =
k *  *[k + ( N -1 )] k + ( N -1 )
Es fácilmente deducible que →1 cuando n →. Notar que  = G / k.
Así, la Productividad que se define como el número de tareas (instrucciones) producidas por
unidad de tiempo es:  = N / t. Sustituyendo la expresión del tiempo de ejecución del
segmentado, nos queda:
N 
= = =f
K   + ( N -1 )   
Nótese que la productividad, entonces depende de la eficiencia y que la Productividad máxima

 = f.
2.3 CLASIFICACION DE LOS PROCESADORES ENCAUZADOS.
Existen varios criterios de clasificación:
A) Por Niveles de procesamiento (Händler):
❖ Cauce de Instrucciones.
➢ Ejemplo del DLX
Página 26
❖ Cauce Aritmético.
➢ Ejemplo del sumador de PF
❖ Encauzamiento de Procesadores.
➢ No es práctico.
B) Dependiendo de las configuraciones y estrategias de control:
❖ Unifunción – Multifunción
❖ Estático – Dinámico
❖ Escalares – Vectoriales
2.4 EL PROCESADOR SEGMENTADO DLX
En este curso, presentaremos el procesador segmentado DLX como caso de estudio

idóneo para la segmentación lineal. El DLX es un modelo didáctico propuesto por Hennessy y
Patterson en [Hen90] para el estudio de arquitectura de computadoras desde un enfoque
cuantitativo. Su nombre deriva del promedio (expresado en números romanos) de los números
de modelo de diferentes arquitecturas actuales que inspiraron su diseño. Según los autores, debe
pronunciarse DéLuX.
El DLX es un procesador RISC de 32 bits, segmentado en 5 etapas. Es una máquina de carga-

almacenamiento, es decir que sólo estas dos instrucciones acceden a memoria y todas las de
cálculo se efectuan estre registros del procesador. La etapas del DLX son las siguientes:
BUS o IF Etapa de búsqueda o fetch de la intrucción e incremento del pc
DL o ID Decodificación/Carga de operandos (registros) en ALU.
ALU o EX Ejecución de operaciones y cálculo de direcciones efectivas de

datos en memoria.
MEM Accesso a memoria para lectura (M→ R) o para escritura

(R→M).
ESC o WB Escritura de resultados en los registros.
A continuación se presenta una pequeña comparación entre las Arquitecturas RISC/CISC con el objetivo
de facilitar al lector la comprensión del funcionamiento del DLX que se expondrá luego en este
documento.
Página 27
RISC CISC
Pocos formatos de instrucciones y Muchos formatos muy complejos que

sencillos permiten decodificador rápido normalmente requieren unidad de control
y control cableado. microprogramada.
Las operaciones de cálculo son registro- Las operaciones permiten operandos en

registro. Instrucciones específicas de memoria.
carga y almacenamiento.
Usan la mínima cantidad de modos de Buscan permitir la máxima cantidad de

direccionamiento. modos de direccionamiento.
Programas largos pero sencillos. Programas cortos pero complejos.
Más fácil de segmentar por su sencillez. Más difícil de segmentar y controlar.
Mayor rapidez de ejecución. Ejecución más lenta (complejidad + UC

Prog)
CONJUNTO DE INSTRUCCIONES DEL DLX
Aunque el repertorio provisto por Hennesy-Patterson es bastante extenso, nos

limitaremos a un conjunto mínimo de Macro-instrucciones que caracterizan suficientemente el
procesador para nuestro estudio:
Cálculo OP R1, R2, R3 ; R1 = R2 OP R3
Acceso a LOAD R1, d(R2) ; R1 = M( R2 + d )

Memoria
STORE d(R2), R1 ; M( R2 + d ) = R1
Saltos BRx R1, d ; If ( R1 cond 0) then PC = PC +

d
Nota: x puede ser:
E ( cond es = ) NE ( cond es # )
LT ( cond es < ) LE ( cond es <= )
GT ( cond es > ) GE ( cond es >= )
Nótese que la instrucción OP es genérica acá por razones de simplicidad, sin embargo OP puede
ser cualquier operación binaria soportada por DLX, por ejemplo: ADD, SUB, AND, OR, etc.
A partir de esta definición de instrucciones, requerimos una arquitectura básica para el DLX
capaz de ejecutar las operaciones que ejecuten las instrucciones. Posteriormente, mejoraremos
esta arquitectura básica a fin de resolver ciertos problemas de la segmentación (riesgos
estructurales)
Página 28
Rd Write
DataBus
mdr
BR
ir M
Rf1 R Rf2 R
@Bus
4
mar
A B
pc
A B
ALU
buff
Figura 2.4. Arquitectura básica del DLX
2.5 DIFICULTADES DE LA SEGMENTACION
Dado el alto rendimiento conseguido en una maquina segmentada, parece que cuanto mayor sea
k, mejor rendimiento obtenemos, sin embargo, la verdad es que la segmentación no es tan simple.
Existen situaciones en las que aparecen riesgos por dependencias que limitan la eficiencia del cauce.
Existen tres posibles casos: Riesgos por dependencias de recursos de las etapas, dependencias de datos
y dependencias de control debido a las instrucciones de saltos, según expondremos a continuación:
 Riesgos estructurales: Son conflictos o colisiones en un recurso de ejecución cuando

dos etapas diferentes intentan usarlo simultáneamente. Recordemos que cada etapa debe
tener hardware independiente para realizar su tarea, porque de lo contrario tendríamos
situaciones de competencia (race conditions), que si no se resuelven parquearían el
cauce. Para que un segmentado sea funcional estos riesgos deben resolverse desde el
mismo vuelven a nivel de diseño.
 Dependencias de datos: Surgen cuando el solapamiento de instrucciones pone en

riesgo la secuencia lógica resultados en un programa, por ejemplo, una instrucción Ij
posterior a Ii no puede continuar porque uno de sus operandos –que era resultado de Ii
no ha sido actualizado –
 Dependencias de control: surgen de la segmentación de los saltos que cambian el valor

el PC.
Página 29
Además, existe el problema de tratamiento de Excepciones (interrupciones síncronas) debido

a la existencia de múltiples instrucciones en ejecución de forma simultánea. Los riesgos en la
segmentación pueden hacer necesario detener el cauce. La diferencia principal entre
detenciones en una maquina segmentada y en una no segmentada se presenta porque hay
múltiples instrucciones ejecutándose a la vez. Una detención, en una maquina segmentada,
requiere con frecuencia que prosigan algunas instrucciones, mientras se retardan otras.
Normalmente, cuando una instrucción esta detenida, todas las instrucciones posteriores a esa
instrucción también se detienen. Las instrucciones anteriores a la instrucción detenida pueden
continuar, pero no se buscan nuevas instrucciones durante la detención. Una detención hace
que el rendimiento de la segmentación se degrade con relación al rendimiento ideal.
2.6 DEPENDENCIAS ESTRUCTURALES
Cuando se segmenta una máquina, la ejecución solapada de instrucciones requiere que

cada etapa sea especializada en una subtarea de la ejecución y cuente con recursos
independientes asociados a esa etapa, de lo contrario, el acceso simultáneo a un recurso puede
crear situaciones de competencia o race conditions durante la ejecución que no pueden
resolverse postergando el acceso, pues todas las etapas deben proceder al unísono.
La única forma de evitar los riesgos estructurales consiste en dirimir la competencia desde el
diseño mismo de la máquina, definiendo qué etapa tendrá la supremacía de cada recurso y
duplicando recursos si es necesario. Un segmentado sin riesgos estructurales resueltos no es
una máquina práctica, pues probablemente nunca logre funcionar.
Aunque muchos riesgos estructurales de la segmentación pueden detectarse a proiri por simple
inspección, –como en el caso del acceso a memoria en BUS y MEM, o el incremento del PC en
BUS y cálculo en ALU– para detectar y corregir todas las dependencias estructurales en forma
detallada, recurrimos a la Tabla de Reserva. La tabla de reserva es una herramienta útil para
analizar los recursos ocupados por cada etapa de la segmentación por lo cual se pueden
identificar fácilmente los riesgos y tomar las medidas de diseño para solventarlos.
2.6.1 TABLA DE RESERVA DEL DLX
La Tabla de Reservas es un instrumento muy útil en la detección y solución de riesgos

estructurales. En ésta se mapean las etapas del cauce en las columnas de la matriz contra las
instrucciones del segmentado que ocupan las filas. En cada celda en la intersección aparecen
tanto las acciones que debe ejecutar el procesador en cada la etapa de acuerdo a la instrucción
como los recursos que trata de ocupar la misma.
Página 30
Instrucción BUS D/L ALU MEM ESC
rd = rf1 op mar = pc decodificar

rf2 mdr = A = rf1 buff = A op - rd = buff
M(mar) B = rf2 B
OP ir = mdr
pc = pc + 4
rd = mar = pc decodificar mar = A + B

M(rf1+d) mdr = A = rf1 mdr = rd = mdr
M(mar) B=d M(mar)
LOAD ir = mdr
pc = pc + 4
M(rf1+d) = mar = pc decodificar mar = A + B

rf2 mdr = A = rf1 M(mar) = -
M(mar) B=d mdr
STORE ir = mdr mdr = rf2
pc = pc + 4
if (cond) mar = pc decodificar buff = A + B if (cond)

pc = pc + d mdr = A = pc cond = pc = buff -
M(mar) B=d (A’ cmp
BRx ir = mdr A’ = rf1 0)
pc = pc + 4
2.6.2 RIESGOS ESTRUCTURALES EN EL DLX
1. Sistema de Memoria: Probablemente el impacto más grande de la segmentación sobre los

recursos de la máquina esté en el sistema de memoria. Aunque el tiempo de acceso no haya
cambiado, el ancho de banda de la máquina debe incrementarse puesto que hay que
proporcionar dos accesos a memoria por cada ciclo de reloj: uno para instrucciones y el otro
para datos. En los RISC esto se resuelve implementando un sistema con dos caches, una
para datos y la otra para instrucciones.
2. Recursos de cálculo: Notamos 3 posibles riesgos en los órganos de cálculo del DLX :
 La etapa BUS requiere calcular el incremento del PC en 4 para lo cual solicitaría los
servicios de la ALU y a su vez, la etapa ALU requiere aplicar A OP B, para lo cual
solicita los servicios de la ALU.
 Por otro lado la instrucción BRx requiere comparar rf1 con 0 en la etapa ALU, lo cual
genera un conflicto incluso internamente dentro de la misma etapa (usar ALU para
ambas operaciones de forma secuencial sería inadmisible porque incrementaría la
duración del ciclo de máquina.
 Finalmente, al BR se solicitan dos lecturas y una escritura simultáneamente.
Página 31
Estos riesgos se solucionan:
 Se debe agregar un sumador a la etapa BUS para incrementar PC.

 Además de la ALU, en la etapa ALU se debe agregar un Comparador: cond = (A’ cmp
0)
 Se debe diseñar el BR para permitir dos lecturas al inicio del período y una escritura al
final del mismo.
3. Latches: Los latches, por regla general, deben leerse al principio del período y escribirse al
final de éste –garantizando la función de retención entre etapas– con lo cual los datos sólo
deben permanecer en estos durante un período. Por otro lado, sólo una etapa puede escribir
en cada uno de ellos, pues de otro modo podríamos tener competencia o colisión. En el
DLX, es necesario revisar las instrucciones para determinar cuándo aparecen dependencias
estructurales de uso de latches. Podemos establecer tres criterios para determinar y solventar
tales dependencias:
 Si se escribe en un latch en la etapa e y se lee hasta en la e+2 o posterior, se corre el

riesgo de perder el valor original. Esto ocurre en OP con buff y en STORE con mdr.
En este caso hay que duplicar latches para solucionar la dependencia.
 No se permite a dos etapas diferentes escribir en el mismo latch, se corre el riesgo

de provocar una colisión en el acceso al latch cuyo desenlace sería impredecible
(pues se deja al hardware definir cuál dato se escribirá de los dos ). Para resolver
esto, hay que usar diferentes latches como destino de escritura en cada etapa. El
único caso especial es el PC que puede escribirse en la etapa BUS y en MEM, sin
embargo aquí la competencia está disuelta por la precedencia del salto sobre la
secuencia y por tanto, en este caso, los posibles valores se multiplexan dejando como
trabajo a la unidad de control establecer cuál de ellos se escribe en PC.
 Las lecturas múltiples a un mismo latch por diferentes etapas no generan

dependencias ni tampoco las escrituras al mismo latch por la misma etapa de
diferentes instrucciones.
4. Información de la Instrucción en ejecución en cada etapa: El segmentado requiere saber

en cada momento qué instrucción se está ejecutando en cada etapa para poder genera las
señales de control, por tanto el IR debe multiplicarse a fin de propagar la instrucción a lo
largo del cauce. En el DLX, necesitamos, además del IR que se escribe en la etapa BUS,
réplicas IR2 en la etapa D/L, IR3 en la etapa ALU e IR4 en la etapa MEM.
Página 32
Tabla 2.1. Resumen de Riesgos estructurales con sus soluciones.
Tipo de recurso Riesgos Solución

Sistema de Memoria Acceso a Memoria en BUS y MEM Usar dos caches: una de instrucciones iCache en la
etapa BUS y otra de datos dCache en la etapa MEM
Recursos de Cálculo Conflicto uso ALU: BUS para incrementar Usar un sumador en BUS (PC = PC+4)
PC, ALU para operar A y B y ALU para usar una ALU en ALU (ALUout = A OP B)
comparar. usar un comparador en ALU (cond = A’ cmp 0)
Latches Sobreescritura de latches Duplicar latches.

Colisión acceso a escritura simultánea El PC es caso especial: se multiplexa.
Instrucción en etapa Perder la información de qué instrucción Crear réplicas del IR en cada etapa excepto ESC
se esta ejecutando en cada etapa. para propagar la Instrucción junto a sus datos.
2.6.3 TABLA DE RESERVA CON DEPENDENCIAS ESTRUCTURALES RESUELTAS
Instrucción BUS D/L ALU MEM ESC
rd = rf1 op rf2 ir = Mi(pc) decodificar

pc = pc + 4 A = rf1 mar = A op B mdrin = mar rd = mdrin
OP B = rf2 ir3 = ir2 ir4 = ir3
ir2 = ir
rd = M(rf1+d) ir = Mi(pc) decodificar

pc = pc + 4 A = rf1 mar = A + B mdrin = Md(mar) rd = mdrin
LOAD B=d ir3 = ir2 ir4 = ir3
ir2 = ir
M(rf1+d) = rf2 ir = Mi(pc) decodificar mar = A + B

pc = pc + 4 A = rf1 mdrout = mdr M(mar) = mdrout -
STORE B=d ir3 = ir2 ir4 = ir3
mdr = rf2
ir2 = ir
if (cond) ir = Mi(pc) decodificar mar = A + B if (cond)

pc = pc + d pc = pc + 4 A = pc cond = pc = mar -
B=d (A’ cmp 0) ir4 = ir3
BRx A’ = rf1 ir3 = ir2
ir2 = ir
Obviamente, estas modificaciones requieren rediseñar la estructura del Procesador para reflejar
todos estos cambios y poder detectar los requerimientos de control. Se denomina camino de
datos o DataPath al diagrama de la estructura del procesador, diseñado de forma tal que muestre
de forma clara la trayectoria que deben seguir los datos dentro del procesador.
Página 33
2.6.4 DATAPATH DEL DLX
DLX Datapath - Dependencias estructurales resueltas

Sistema de Memoria Señales de Control
Reloj
R/W
BUS
@Inst ICache:R/W
PC
iCache S
4 Reloj
Inst
IR
(offset d)
BR D/L
BR:@Rf1(CO, R1), Read
Rf1 R Rf2 R BR:@Rf2(CO, R2), Read
MuxA(CO)
MuxB(CO)
Reloj Reloj Reloj Reloj
A' A B MDR IR2
ALU
0
ALUsel(CO)
Comp ALU
Reloj Reloj
Reloj Reloj
Cond MAR MDROUT IR3
R/W
@datos MEM
datos_out dCache:R/W(CO)
dCache
datos_in
Reloj
Reloj
MDRIN IR4
Rd Write
ESC
BR:@Rd(CO, Rd|R2)
BR
Figura 2.5. Datapath del DLX con dependencias estructurales resueltas
Página 34
2.7 DEPENDENCIAS DE DATOS
Las lecturas y escrituras de los datos deben ejecutarse en el orden que establece la
secuencia lógica del programa. La segmentación permite iniciar la ejecución de instrucciones
posteriores antes que se completen las anteriores, con lo cual se corre el riesgo de leer o escribir
datos en un orden incorrecto si una instrucción j opera sobre los mismos registros que una
instrucción anterior i. Un buen diseño de procesador segmentado no debe permitir la ejecución
de estas instrucciones posteriores hasta que se pueda garantizar la coherencia de los datos.
Veamos un R1 se escribe aquí

Esc
ejemplo: (i) OP R1, R2, R3
D/L
(j) OP R5, R1, R7
Necesito el valor de R1 aquí
En este caso la instrucción j requerirá en la etapa D/L un dato que no será actualizado hasta tres
ciclos después. Si el programa continúa, los resultados no serían los esperados, por tanto el
encauzado deberá detener todas las etapas anteriores a D/L hasta que R1 se haya actualizado.
Estas detenciones del cauce, denominadas latencias, merman la eficiencia porque en estos
ciclos no se producen instrucciones. Las dependencias de datos deben tratarse tanto para evitar
resultados incoherentes como para minimizar las latencias que provocan pérdidas en el
desempeño del segmentado.
2.7.1 TIPOS DE DEPENDENCIAS DE DATOS
Formalmente, si llamamos dominio D a los operandos (lecturas) de una instrucción y recorrido

R a su resultado (escritura), podemos decir que existe dependencia de datos entre dos instrucciones
cuando la intersección ya sea del dominio o recorrido de la una de ellas con el dominio o recorrido de
la otra es diferente del conjunto vacío. Según esta definición podemos diferenciar cuatro tipos de
dependencias de datos posibles:
D(i)  D(j)  ( simplificadamente D-D o RAR)

D(i)  R(j)  ( simplificadamente D-R o WAR)
R(i)  D(j)  ( simplificadamente R-D o RAW)
R(i)  R(j)  ( simplificadamente R-R o WAW)
D-D: La instrucción j posterior trata de leer un dato antes que la instrucción i anterior lo haya
hecho. Desde el punto de vista de datos no representa problemas, sin embargo presupone
requerimientos estructurales (como varios buses o puestos de lectura en el banco de registro).
Esta dependencia suele llamarse RAR, como siglas de Read After Read.
Página 35
D-R: J trata de escribir un registro antes que una instrucción i anterior lo haya leído, violación
al orden Write After Read (WAR). Esta dependencia no ocurre en cauces lineales con ejecución
en orden, sin embargo puede ocurrir en cauces multiciclo cuando la ejecución ocurre en
desorden o en segmentados con ejecución dinámica.
R-D: Problema típico de los segmentados. Consiste cuando la instrucción j trata de leer datos
que no han sido escritos por la instrucción i anterior a ella, tratando de romper el orden Read
after Write o RAW. El ejemplo mostrado de dependencia con R1, es un caso típico de R-D :
R(i)  D(j)  , pues R(i)  D(j) = {R1}
R-R: No puede ocurrir en el DLX dado que sólo se escribe en una única etapa, pero básicamente
puede aparecer en cualquier segmentado donde se escriba en diferentes etapas ( Write After
Write o WAW).
Dados los alcances del curso, sólo enfocaremos las dependencias R-D por ser las más comunes
y las únicas que se presentan en nuestro modelo. Lectores interesados en le tema pueden
encontrar más material en las obras de Henessy y Patterson.
2.7.2 TRATANDO LAS DEPENDENCIAS DE DATOS EN EL DLX

Hay dos formas de tratar las dependencias de datos en el DLX: a nivel de mejora de diseño para
minimizar la penalización por latencias y a nivel de detención para evitar incoherencias. En el
DLX hay un máximo de 4 posibles latencias por dependencias.
Valor actualizado de R1
disponible aquí
R1 se escribe aquí
ALU Esc
D/L
1ra Latencia
2da Latencia
3ra Latencia
4ta Latencia
Necesito el
valor de R1
aquí
2.7.2.1 MEJORAS DE DISEÑO:
 Garantizar que las lecturas ocurren luego de las escrituras del ciclo anterior (Esto se
garantiza estructuralmente en el DLX). Elimina la posible 4ª latencia.
 Usar la técnica de forwarding, bypassing o cortocircuito para adelantar el dato actual a

donde se requiere sin esperar a que esté escrito en el Banco de registros.
Página 36
Por ejemplo, Nótese que el valor de R1 en el ejemplo está disponible en la salida de la ALU de la
instrucción i, por tanto, ésta puede cortocircuitar con su entrada, permitiendo el manejo correcto del dato
mediante la selección de MuxA y MuxB en la instrucción j, eliminando así la 1ª latencia. Estos sólo
puede lograrse mediante un riguroso control pues nótese que aparentemente el valor de R1 se solicita al
inicio del ciclo y la salida de la ALU está disponible hasta el final del mismo, sin embargo recuérdese
que los registros A y B se escriben al final del ciclo también, por tantoel valor de la salida de la ALU
puede estar disponible con suficiente tiempo para escribir en A o B. esto es posible pues la instrucción
en la etapa D/L se tiene en el IR y la instrucción en ALU en el IR2 por tanto el control puede hacer el
cortocircuito inequívocamente.
También se pueden adelantar las salidas del MuxMDRin y del MDRin hacia MuxA y MuxB
a fin de eliminar las latencias 2 y 3 con la instrucción OP. Veamos en el ejemplo a continuación
cómo se darían estos cortocircuitos o adelantamientos:
disponible aquí
R1 se escribe aquí
ALU Mem Esc Cortocircuitos que adelantan

el valor de R1 eliminando las
D/L ALU posibles latencias para
operaciones como OP
se ocupa aquí
Los cortocircuitos aplicados son:
OP(i) – OP(i+1) : S(ALU) → E(A)|E(B) Es decir, que la salida de la ALU se lleva a la

entrada
del registro A o del registro B (entrad de la ALU)
OP(i) - OP(i+2) : S(MAR) → E(A)|E(B) En este caso, el valor de R1 ya está más próximo, se
lleva de la etapa MEM al inicio de la etapa ALU.
OP(i) - OP(i+3) : S(MDRin) → E(A)|E(B) R1 ya está en la etapa Esc pero no se escribirá hasta el
próximo ciclo por cuanto hay que adelantar la salida
de MDRin a la entrada de la ALU.
No todos los casos de dependencias de datos en el DLX se pueden resolver con cortocircuitos,
la dependencia LOAD(i) – OP(i+1), por ejemplo, no pueden tratarse con cortocircuitos pues no
hay suficiente tiempo para lograr Salida(MEM) → Entrada(ALU). Hay que buscar otras
técnicas en estos casos.
Valor actualizado
disponible aquí
ALU MEM Esc

D/L
Valor actualizado
requerido aquí
Página 37
2.7.2.2 INTERLOCK POR HARDWARE
Para los casos de implementación de DLX en que no se realizaron mejoras de diseño, y para los casos
en que las mejoras no permiten eliminar todas las latencias, se deben parar las inicializaciones del cauce
y esperar hasta que el resultado esté disponible.
Esto puede hacerse por hardware. La unidad de control puede disponer de un órgano de detección de
dependencias de datos que genere una señal cuando la nueva instrucción cargada en IR tiene
dependencia con alguna de las instrucciones en ejecución (comparación de los Rf en IR con los Rd en
IR2, IR3 e IR4). Cuando se dé el caso de dependencia, entonces deberá congelarse la etapa BUS (no
cargar PC+4, pero sí si es destino de salto) e introducir NOP por hardware en IR2 a fin de insertar una
burbuja o ranura de retardo (delay slot) que permita esperar hasta que el resultado esté disponible en el
banco de registros para continuar con la instrucción postergada en IR.
2.7.2.3 TRATAMIENTO POR SOFTWARE
 Finalmente, el compilador o el programador a bajo nivel puede introducir ciclos sin

ejecución (de relleno) mediante la instrucción NOP.
 Otro método, propio para compiladores y más eficiente, consiste en reordenar las
instrucciones a fin de evitar las dependencias.
2.7.3 RESUMEN DE DEPENDENCIAS DE DATOS EN EL DLX
Instrucciones Escenario Tratamiento

Involucradas
OP - OP OP(i) – OP(i+1) S(ALU) → E(A)|E(B)
OP(i) – OP(i+2) S(MAR) → E(A)|E(B)
OP(i) – OP(i+3) S(MDRin) → E(A)|E(B)
OP - LOAD OP(i) – LOAD(i+1) S(ALU) → E(A)
OP(i) – LOAD (i+2) S(MAR) → E(A)
OP(i) – LOAD (i+3) S(MDRin) → E(A)
OP – STORE OP(i) – STORE(i+1) S(ALU) → E(A)
CASO 1:
OP(i) – STORE S(MAR) → E(A)
OP r1, r2, r3 (i+2)
STORE r5, d(r1)
OP(i) – STORE S(MDRin) → E(A)
(i+3)
OP – STORE OP(i) – STORE(i+1) S(ALU) → E(MDR)

CASO 2:
Página 38

Involucradas
OP(i) – STORE S(MAR) → E(MDR)
OP r1, r2, r3 (i+2)
STORE r1, d(r4)
OP(i) – STORE S(MDRin) → E(MDR)
(i+3)
LOAD - OP LOAD(i) – OP(i+1)Parar el cauce:

IR=OP y IR2=LOAD y IR2(Rd)= (IR(Rf1) | IR
(Rf2))
LOAD(i) – OP(i+2) S(Md) → E(A)|E(B)
LOAD(i) – OP(i+3) S(MDRin) → E(A)|E(B)
LOAD - LOAD LOAD(i) – Parar el cauce:
LOAD(i+1) IR=LOAD y IR2=LOAD y IR2(Rd)=IR(Rf1)
LOAD(i) – LOAD S(Md) → E(A)
(i+2)
LOAD(i) – LOAD S(MDRin) → E(A)
(i+3)
LOAD – STORE LOAD(i) – Parar el cauce:
CASO 1: STORE(i+1) IR=STORE y IR2=LOAD y IR2(Rd)=IR(Rf1)
LOAD(i) – S(Md) → E(A)
LOAD r1, d(r2) STORE(i+2)
STORE r5, d(r1) LOAD(i) – S(MDRin) → E(A)
STORE(i+3)
LOAD – STORE LOAD(i) – S(Md) → E(MDRout)
CASO 2: STORE(i+1)
LOAD(i) – S(MDRin) → E(MDRout)
OP r1, r2, r3 STORE(i+2)
STORE r1, d(r4) LOAD(i) – S(MDRin) → E(mdr)
STORE(i+3)
STORE - NO HAY
Cualquiera
OP – BRx BRx va a cambiar (Con la solución de riesgos de control)
LOAD – BRx
BRx - Cualquiera NO HAY
Página 39
2.7.4 DATAPATH DEL DLX CON DEPENDENCIAS DE DATOS RESUELTAS
DLX Datapath - Dependencias de datos resueltas

Reloj
R/W Ld_PC BUS
@Inst ICache:R/W
PC
iCache S
4 Ld_IR Reloj
Inst
IR
(offset d) D/L
BR:@Rf1(IR), Read
BR BR:@Rf2(IR), Read
MuxA'(IR, (IR3, IR3, IR4))
MuxA (IR, (IR3, IR3, IR4))
(a, b, c) Rf1 R Rf2 R
(a, b, c) MuxB (IR, (IR3, IR3, IR4))
NOP
(a, b, c) MuxMDR(IR, (IR3, IR3, IR4))
Ld_PC(IR, IR2)
Ld_IR(IR, IR2)
Reloj Reloj Reloj Reloj MuxIR2(IR, IR2)
A' A B MDR IR2
0 ALU
ALUsel(IR2)
(b) Comp(IR2)
Comp MuxMDRout(IR2, IR3)
ALU
(a)
Reloj Reloj Reloj Reloj
Cond MAR MDROUT IR3
R/W MEM
@datos
dCache:R/W(IR3)
datos_out MuxPC(IR3,Cond)
dCache
MuxMDRin(IR3)
datos_in
Reloj (b) Reloj
MDRIN IR4
(c) ESC
Rd Write
BR:@Rd(IR4), Write
BR
Nota: Los cambios respecto al DataPath con Dep. Estructurales resueltas se muestran en azul fuerte
Figura 2.6. Datapath del DLX con dependencias de datos resueltas
Página 40
2.8 DEPENDENCIAS DE CONTROL
Las dependencias de control en los segmentados son introducidas por las instrucciones
de salto, BRx en el caso específico del DLX. Nótese que la instrucción de salto, actualiza el
valor del PC hasta en la etapa MEM, por tanto las instrucciones cargadas en el cauce deben
eliminarse del mismo pues su ejecución sería inválida si la condición resultase verdadera y el
salto se hiciera efectivo. El gran problema consiste en que estas instrucciones podrían cambiar
el estado del procesador generando resultados inesperados, por tanto, el procesador debería
bloquear la carga de nuevas instrucciones hasta que se actualice el valor del PC correctamente,
lo cual genera 3 latencias por cada instrucción de salto:
if (cond) ir = Mi(pc) decodificar mar = A + B if (cond)

pc = pc + pc = pc + 4 A = pc cond = pc = mar -
d B=d (A’ cmp
A’ = rf1 0)
BRx
PC
MEM
BRx i
Consideremos que en un programa típico, los saltos representan entre un 15% y un 30% de las
instrucciones, por tanto, las dependencias de control, deben considerarse muy seriamente
porque degradan el desempeño del segmentado de forma significativa.
Ejemplo: Supongamos que en un programa, el 20% de instrucciones son BRx e idealicemos

diciendo que no hay paradas por dependencias de datos, entonces nuestro ciclo de máquina real,
viene a ser:
r = 0.2 ( + 3) + 0.8  = 1.6 

Nota: El ciclo de máquina se incrementa en un poco más del 50%.
2.8.1 ADELANTANDO LA DEFINICION DEL SALTO
Mejorando el diseño, podemos adelantar el salto a la etapa ALU. Esto no implica ningún
requerimiento especial y elimina una latencia.
Página 41
PC
ALU
BRx i
Según el k ejemplo
anterior, el ciclo de máquina
real, con el adelantamiento es:
r = 0.2(  + 2) + 0.8  = 1.4 
if (cond) ir = Mi(pc) decodificar mar = A + B

pc = pc + pc = pc + 4 A = pc if = (A’ cmp 0) - -
d B=d pc = A + B
A’ = rf1
BRx
Sin embargo, todavía es una penalización grande. ¿Podemos mejorar? – ¿Qué tal si tratamos
de pasar el salto a la etapa D/L, para tener sólo una latencia?
PC
BRx D/L
i
Este adelantamiento implica ciertos requerimientos estructurales:
 Se necesita un sumador adicional en la etapa D/L.

 Debe pasarse el comparador de la etapa ALU a la etapa D/L.
 Como D/L es la etapa más rápida, lo más seguro es que no se requiera agrandar .
En este caso el ciclo real de máquina debido a la penalización por saltos viene a ser:
r = 0.2 ( + ) + 0.8  = 1.2 
if (cond) ir = Mi(pc) decodificar

pc = pc + pc = pc + 4 if = (Rf1 cmp 0) - - -
d pc = pc + d
BRx
El salto no puede adelantarse más debido a que Rf1 debe leerse del BR. Las mejoras obtenidas
son equivalentes a las obtenidas con las dependencias de datos. Como conclusión: No siempre
podemos evitar las latencias debido a cierta combinación de instrucciones y éstas implicarán
una merma en el desempeño del DLX.
Página 42
Los adelantamientos, modifican la estructura de la instrucción BRx y con ello, las posibles
dependencias de datos entre ésta y el resto de instrucciones.
Por otro lado, es necesario que el procesador provea un mecanismo de parada por hardware
para tratar la latencia, o en su defecto, el programador o el compilador deberán introducir un
NOP explícitamente después de cada BRx. El segmentado puede tratar el interbloqueo a nivel
de unidad de control introduciendo NOP en la entrada del IR cuando se ha decodificado un
BRx, de forma tal que en el próximo
ciclo, IR2 = BRx e PC IR=NOP.
D/L
BRx i
i+1 k
If (Rf1 cmp 0) : PC = @Salto
else: PC = PC + 4
@Salto
R/W
@Inst PC
iCache NOP
S
4 Reloj
Inst
IR
Figura 2.7. Implementación del interbloqueo por hardware en el DLX
2.8.2 DEPENDENCIAS DE DATOS EN BRx TRAS ADELANTAMIENTO A D/L
Como anotamos anteriormente, el adelantamiento de la instrucción BRx provoca nuevas

dependencias, que no fueron tratadas en el apartado anterior. En la tabla a continuación se
resumen:

Involucradas
OP - BRx OP(i) – BRx(i+1) S(ALU) → E(Cmp) Debe estudiarse si
queda tiempo para que se dé, caso
contrario, parar.
OP(i) – BRx (i+2) S(MAR) → E(Cmp)
OP(i) – BRx (i+3) S(MDRin) → E(Cmp)
LOAD - BRx LOAD(i) – BRx(i+1) Parar el cauce:
IR=BRx y IR2=LOAD y IR2(Rd)= IR(Rf1)
Página 43
LOAD(i) – BRx S(Md) → E(Cmp) Debe estudiarse si

(i+2) queda tiempo para que se dé, caso
contrario, parar.
LOAD(i) – BRx S(MDRin) → E(Cmp)
(i+3)
2.8.3 TRATAMIENTO DE LAS LATENCIAS DE CONTROL
Como no podemos eliminar una latencia debido a saltos, podemos implementar técnicas para
tratar de evitarlas en algunos casos. Existen tres técnicas empleadas:
 Salto retardado (método Software)

 Apuesta por una de las ramas (Software+Hardware)
 Apuesta por ambas ramas (BTB)
2.8.3.1 Salto retardado

Este método es aplicable en tiempo de compilación cuando la máquina no es capaz de bloquear
el cauce por hardware. Consiste en buscar instrucciones de relleno útiles que se ejecuten en
lugar del NOP obligado antes que el salto se haga efectivo. Es equivalente al reordenamiento
de código en caso de dependencias de datos.
Sin embargo, la elección de las instrucciones de relleno no es trivial pues requiere de un análisis
previo de las dependencias de datos entre instrucciones. La primera opción consiste en buscar
una instrucción anterior como relleno, esta no debe tener ninguna dependencia con las
siguientes del bloque. Si no se logra obtener una instrucción apropiada del bloque básico, se
puede emplear una del bloque de continuación o del de salto, siempre que cumplan ciertas
condiciones de independencia de datos y su ejecución no afecte la lógica del programa (por
ejemplo, que no escriba resultados a memoria y que el registro destino sea un registro temporal
donde no importe el valor actualizado por la instrucción).
En el caso de rellenar con una instrucción de continuación, si el salto no se hace efectivo, la

instrucción elegida es útil. En cambio si lo es, se ha garantizado que aunque la ejecución de la
instrucción de relleno no es útil, no perjudica los resultados. Esta estrategia se prefiere cuando
el salto es poco probable, por ejemplo en implementaciones de IF-ELSE. En caso de usarse
relleno desde el bloque de salto, la ejecución de la instrucción de retardo es útil si el salto es
efectivo. Esta elección es preferida cuando el salto es muy probable, como en estructuras de
bucles. Si no se detectan instrucciones de relleno válidas (cuya ejecución en caso de fallo no
sea perjudicial) debe rellenarse con NOPs.
Página 44
Ejemplo:
…
1) MUL R1, R2, R9
2) ADD R7, R1, R9
3) DIV R7, R1, R9
4) SUB R4, R4, R6 Bloque básico
5) BRx R4, d (i)
Continuación Salto
6) MUL R5, R13, R13 (i+1) 9) SUB R12, R7, R1 (k)
7) SUB R15, R7, R8 10) ADD R13, R12, R5
8) SUB R12, R5, R6 11) ADD R6, R5, R6
… …
En este trecho de código, podemos emplear como relleno la instrucción 3 del bloque básico
pero no 1 o 4 porque tienen dependencias R-D ni 2 pues tiene dependencia R-R con 3 (No debe
tener ningún tipo de dependencia con las siguientes de su bloque). Por otro lado, del bloque
de continuación, no debe tener dependencias de ningún tipo con las instrucciones anteriores
de su bloque ni R-D con las del bloque de salto, por tanto solo es elegible 7 (6 tiene R-D con
10 y 11. 8 tiene con 6 y R-R con 7), Finalmente del bloque de salto, la instrucción no debe
tener dependencias con las anteriores de su bloque ni R-D con las del bloque de continuación,
por tanto sólo 9 es apropiada. (10 tiene R-D con 9 y 11 tiene R-D con 8)
2.8.3.2 Apuesta por una de las dos ramas
Esta técnica es una mejora al simple interlock por hardware mencionado anteriormente,
consiste en definir en el diseño del segmentado que se apueste por una de las dos ramas del
salto y permitir mediante control, evitar cambios en el estado del programa cuando la apuesta
es fallida (inhabilitar las escrituras o abortar la ejecución con NOPs). Esta técnica requiere de
soporte de software para el caso de apuesta por la rama de salto.
Si se apuesta por el bloque de continuación, la ejecución de la instrucción que sigue a un BRx

continúa hasta que el se actualiza PC, aquí la Unidad de Control puede saber si el salto fue
efectivo [IR2 = BRx y (Rf1 cmp 0 = verdadero)] y por tanto Bloquear la instrucción: IR = NOP
o dejarla que ejecute bloqueando las escrituras en MEM y BR. Si el salto no fue efectivo, no se
hace nada y no hay latencias.
Si se apuesta por el bloque de salto, el compilador inserta las instrucciones necesarias del bloque
de salto (1 en el DLX), en caso de fallo, se anula la ejecución (bloqueando las escrituras) o se
Página 45
aborta con NOP en IR. Nótese que la responsabilidad del relleno útil descansa sobre el
compilador o el programador en lenguaje de bajo nivel.
Con esta técnica se eliminan las latencias cuando hay aciertos. Una mejora a esta técnica es la
predicción del salto, que resulta muy conveniente por el carácter cíclico de los mismos. Se
requiere almacenar el comportamiento de los saltos para predecir si se toma el salto o no. Se
implementa en firmware y necesita pre-decodificación de las instrucciones de salto. Las
penalizaciones se reducen significativamente.
2.8.3.3 Apuesta por ambas ramas (BTB)
Esta última técnica también aprovecha el carácter repetitivo de los saltos. Se agrega al
procesador un Branch Target Buffer (BTB) o buffer de destino del salto que es una memoria
asociativa donde se almacenan las últimas direcciones de destino de salto y con un MUX se
selecciona la instrucción correcta (cargada de memoria= i+1, o cargada desde el BTB = k).
El procesador siempre procede por el bloque de continuación. Si el salto se toma, debe buscar
la dirección destino en el BTB. La primera vez, seguramente no estará guardada en el buffer y
se deberá anular la ejecución de la instrucción cargada i+1 mediante NOP en IR.
Si la condición de salto es verdadera y @salto está en el BTB, se selecciona la instrucción de

salto k en el MUX y el PC se carga con @salto + 4 para la próxima carga.
Página 46
2.8.4 DATAPATH DEL DLX CON LAS DEPENDENCIAS DE CONTROL RESUELTAS
DLX Datapath - Dependencias de datos resueltas

Reloj @Salto
R/W Ld_PC PC + 4 BUS
@Inst ICache:R/W
PC
iCache S NOP
4 Ld_IR Reloj
Inst
IR
PC d
D/L
BR:@Rf1(IR), Read
S
0 (a, b, c) BR @salto BR:@Rf2(IR), Read
@Salto Cmp(IR); S@Salto(IR)
MuxCmp(IR, (IR3, IR3, IR4))
Rf1 R Rf2 R (offset d)
MuxA (IR, (IR3, IR3, IR4))
(a, b, c) NOP MuxB (IR, (IR3, IR3, IR4))
(a, b, c)
MuxMDR(IR, (IR3, IR3, IR4))
Ld_PC(IR, IR2)
Comp Reloj Reloj Ld_IR(IR, IR2)
Reloj MuxIR(IR)
Cond MuxIR2(IR, IR2)
A B MDR IR2
ALU
ALUsel(IR2)
(b) MuxMDRout(IR2, IR3)
ALU
(a)
Reloj Reloj Reloj
MAR MDROUT IR3
R/W MEM
@datos
dCache:R/W(IR3)
datos_out MuxMDRin(IR3)
dCache
datos_in
Reloj
Reloj (b)
MDRIN IR4
(c) ESC
Rd Write
BR:@Rd(IR4), Write
BR
Nota: Los cambios respecto al DataPath con Dep. de Datos resueltas se muestran en azul fuerte
Figura 2.8. Datapath del DLX con las dependencias de control resueltas
Página 47
2.9 EXCEPCIONES
2.9.1 INTRODUCCION
Las interrupciones son mecanismos que permiten el desvío (o suspensión momentánea) del
flujo en ejecución debido a la necesidad de atención de algún evento. Estas pueden clasificarse en
asíncronas y síncronas.
 Asíncronas: ocurren en cualquier momento y no dependen del flujo actual de ejecución,

por ejemplo las solicitudes de atención de los dispositivos de entrada/salida.
 Síncronas: aparecen como efecto de situaciones excepcionales ocurridas durante la
ejecución de una instrucción, por lo cual algunos autores les llaman excepciones.
Ejemplo de excepciones son el fallo de bloque de caché, el overflow y la división por
cero.
Cuando ocurren las primeras, el procesador guarda el estado de la máquina (generalmente el

PC) y fuerza un trap en próximo ciclo a fin que la próxima instrucción que se carga es la primera
de la rutina del sistema que trata las interrupciones, de esta manera las instrucciones en el cauce
se terminan de ejecutar y no ocurren latencias de ningún tipo.
En el caso de las excepciones, el problema es que ocurren durante la ejecución de una

instrucción que puede abortarse debido a la excepción o debería recomenzarse después que la
rutina de tratamiento de interrupciones concluya.
2.9.2 EXCEPCIONES EN EL DLX
En el DLX, pueden aparecer excepciones en las etapas BUS, MEM (acceso a caché),
D/L (código de operación ilegal) y ALU (excepciones aritméticas). Las primeras deben ser
recomenzables en tanto las últimas por lo general abortan la ejecución de la instrucción o del
programa y la rutina de tratamiento del sistema o el sistema operativo se encargan de tratarlas.
Cuando ocurre una excepción en el DLX, éste debe:
 Forzar una instrucción de trap en la etapa BUS, en el siguiente ciclo. Esta instrucción
se encarga de invocar a la rutina de tratamiento de excepciones del sistema.
 Hasta que el trap sea efectivo, se deben inhibir todas las escrituras para la instrucción
que generó la excepción. y las instrucciones posteriores a ellas, evitando así que se
cambie el estado de la ejecución y se obtengan resultados erróneos.
 Una vez que el trap comienza a ejecutarse, el DLX debe guardar el valor del PC de la
instrucción que generó el fallo, para poder recomenzarla. En máquinas donde se
implementa el salto retardado, el valor del PC no puede determinarse de forma
secuencial y por tanto es necesario guardar réplicas del PC a lo largo de todo el cauce
para poder recomenzar la ejecución de las instrucciones.
Página 48
Cuando la rutina de tratamiento de interrupciones se concluye, hay que recomenzar las

instrucciones que se estaban ejecutando en el momento de la excepción. Esto puede hacerse
reinicinado el PC con la dirección de la instrucción que generó la excepción y los PC’s a
continuación de ésta en caso de saltos.
Si un procesador puede inhibir toda la ejecución de las instrucciones siguientes a la causante de
la excepción, tratar la excepción y recomenzar la ejecución volviendo a cargar la instrucción
que causó el fallo, se dice que tiene tratamiento preciso de excepciones. Esto es deseable en
muchos procesadores.
Pero no siempre tenemos un panorama tan limpio, pues pueden surgir mayores complicaciones cuando
se presentan múltiples excepciones. El caso más complicado es cuando instrucciones posteriores
generan sus excepciones antes que las anteriores, de forma tal que tratarlas no es un caso tan trivial como
cuando hay una sola excepción en el cauce. Se aplican dos técnicas:
a) Tratar las excepciones en el orden de las instrucciones (vector de status de excepciones): El

procesador se auxilia de un vector de estatus que se arrastra con cada instrucción. Cuando
aparece una excepción, se inhiben las escrituras de esta instrucción y sus sucesores y el cauce
sigue avanzando, En el final de la etapa MEM, siempre se verifica el vector de status, y si hay
excepciones se tratan y se reinicia esa instrucción. Esto nos garantiza que las excepciones se
traten de forma precisa.
b) Tratar las excepciones en el orden de aparición, lo cual requiere detener no solo los sucesores
sino los antecesores que puedan cambiar el estado de la máquina. Una vez resuelta la excepción
se inicia en la instrucción más antigua que se detuvo.
2.10 SEGMENTACION NO LINEAL
La segmentación lineal se caracteriza por un estricto orden de precedencia en la

ejecución de las subtareas del cauce, lo cual puede expresarse mediante un grafo de precedencia
lineal. La segmentación no lineal o general, es aquella que permite ciertas flexibilidades en el
orden y forma de ejecución de estas subtareas y se caracteriza por un grafo no-lineal.
out
3
in 1 2 3
out 1
T1 T3 T2 T4
T1 T2 T3 T4
in 4
2
Grafo de Precedencia Lineal Grafo de Precedencia No lineal
Figura 2.9. Grafos de precedencia
En la segmentación lineal, representada por el primer gráfo, el flujo de datos o tareas pasa por todas y
cada una de las etapas en el orden de las mismas una sola vez. En la segmentación no lineal, dependiendo
de la función del cauce, las tareas pueden:
▪ No pasar por todas las etapas.

▪ Tener múltiples puntos de entrada y salida
▪ Estar en posibilidad de pasar por (ocupar) varias etapas a la vez.
Página 49
▪ Tener caminos alternativos según se requiera en la ejecución.

▪ Repetir el paso por una etapa de manera cíclica (procesadores multiciclo).
▪ Repetir el paso por una etapa ocupada varios ciclos atrás (retroalimentación o feed back).
Nótese que la segmentación lineal está relacionada con cauces de instrucción y los no lineales o
generales, con cauces del tipo aritmético o de procesamiento de vectores. Los enlaces entre las etapas
del cauce nos permiten identificar si son lineales o no. El diagrama de bloques es un esquema
simplificado del cauce al cual se ha despojado de los detalles de acoplamiento (latch) y temporización.
En en las figuras 8 y 9 pueden apreciarse las diferencias entre los diagramas de bloque de un cauce
lineal y uno no lineal.
S1 S2 S3 S4 S5
Figura 2.10. Diagrama a bloques de un segmentado lineal.
S1 S2 S3 S4 S5
Figura 2.11. Diagrama a bloques de un segmentado no-lineal.
Los círculos con signos de conmutación al centro, son multiplexores. Estos permiten seleccionar la
entrada correcta a cada etapa en cada ciclo de reloj. Es obvio que dadas las posibilidades de feedback
del cauce, pueden existir muchos caminos o trayectorias de cada tarea. Esto es particularmente cierto en
cauces con caminos alternativos o reconfigurables ya sea de manera estática o dinámica.
2.11 PROCESADORES MULTICICLO
Algunos procesadores implementan operaciones especiales como aritmética en punto

flotante o vectorial para mejorar las prestaciones de la máquina. Muchas de estas operaciones,
pueden emularse con rutinas de software pero su desempeño es muy pobre, por otro lado,
implementarlo en hardware ha requerido de procesadores auxiliares dedicados a este fin pues,
estas operaciones son intensivas y requieren mucho tiempo para completarse, por ejemplo, una
división en punto flotante requiere de 30 a 50 ciclos de máquina.
Para que tales operaciones sean implementables en un segmentado, se requeriría que las
instrucciones pudieran ocupar repetidamente la ALU hasta completar la operación y luego
continuar con la ejecución. A simple vista, esto nos causaría tremendas latencias, sin embargo,
dado que la multiplicidad involucra solo una etapa, se suele multiplicar la ALU en diversas
unidades, permitiendo a algunas tener una instrucción repitiéndose en esta etapa varios ciclos
hasta completarse mientras el proceso de ejecución continúa normalmente. A una máquina que
soporte tal dinámica de trabajo se le llama Procesador Multiciclo.
Página 50
Una modificación del DLX para soporte a operaciones en punto flotante, deberá ser multiciclo.
El esquema de la figura 10 muestra el diagrama a bloques del DLX Multiciclo, con varias
unidades funcionales, básicamente ALUs especializadas en operaciones enteras y/o de punto
flotante.
ALU
E
MUL
E/PF
BUS D/L MEM ESC
SUM
PF
DIV
E/PF
Figura 2.12. DLX multiciclo.
Con los procesadores Multiciclo hay que tener en cuenta que pueden aparecer riesgos R-D.
Con resultados de operaciones en punto flotante, también podrían aparecer riesgos de datos del
tipo R-R.
Para controlar el acceso a las etapas de la ALU, es necesario llevar un registro de su uso así
como de los registros involucrados en las instrucciones. Las diferentes unidades funcionales
de la ALU se controlan mediante un Scoreboard o marcador que tiene un bit de ocupado para
cada etapa así como el registro destino de la operación. Esta técnica es clave para la detección
dinámica de dependencias de datos. Cuando se carga una nueva instrucción se debe comprobar
en el marcador que la unidad a utilizar no esté ocupada, caso contrario se inhibe emisión de la
instrucción en la etapa D/L. Para evitar los riesgos R-R, se debe llevar una secuencia de las
escrituras, permitiendo re-expedición interna en registros temporales e inhibiendo la escritura
de los resultados finales hasta que se garantice el orden en la etapa MEM.
2.12 PLANIFICACION DE RECURSOS
Las dependencias estructurales en los cauces generales consisten en la posibilidad de colisiones

por el intento de uso de una etapa por más de una tarea. Estas dependencias se atacan haciendo una
buena planificación de los recursos que evite las colisiones. A diferencia de la solución de dependencias
estructurales en los cauces lineales, los cauces generales no pueden evitar latencias.
A continuación explicaremos el procedimiento de planificación basado en secuenciamiento de trabajos

y prevención de colisiones. Esta planificación tiene dos objetivos: evitar inicialización de tareas que
generarán colisiones y definir una estrategia de secuenciamiento de trabajos que busque la utilización
óptima del cauce.
Iniciemos con un ejemplo. Usemos el cauce de la figura 9 y definamos su tabla de reserva. En los cauces
generales, necesitamos una tabla para cada función. Por simplificación sólo consideraremos cauces
Página 51
monofunción en nuestro curso. La tabla de reserva se conforma por las etapas del cauce vs períodos de
tiempo o ciclos que requiere la función para completarse. Una marca en el cuadrado, en la intercepción
de Sj con Ti, muestra si la etapa Sj es ocupada por la función F en el ciclo Ti.
Sj \Ti 0 1 2 3 4 5 6 7 8
1 X X
2 X X X
3 X
4 X X
5 X X
Figura 2.13. Tabla de reserva del cauce
Así vemos cómo la función F, ocupa en el primer ciclo (0) la etapa 1, pasa a la 2 en el segundo, se
mantiene en esa etapa en el tercero, pasa a la tercera, la cuarta, repite la cuarta, pasa a la quinta, en la
cual dependiendo de alguna condición, puede pasar a la segunda y luego terminar en la primera o repetir
la quinta y pasar a terminar en la primera.
En función de esta tabla, se pueden definir latencia como el número de ciclos de tiempo entre dos
iniciaciones. El fin del procedimiento de planificación por secuenciamiento de trabajos consiste en
elegir una estrategia de control que consiste en una secuencia de latencias, que minimice la latencia
media entre iniciaciones.
Se inicia por determinar la tabla de reserva y la lista de inicializaciones prohibidas F y libres o permitidas
F’. Son inicializaciones prohibidas aquellas que generan colisiones. El procedimiento recomienda
detectar filas con varias marcas (X) y restar el ciclo menor Ti del mayor Tj, el resultado serán las latencias
prohibidas. Las libres son las latencias no prohibidas o conjunto complemento de F. Para nuestro
ejemplo, estas son:
F = { 1, 5, 6, 8 } F’ = { 2, 3, 4, 7 }
El siguiente paso consiste en determinar el vector de colisiones C. Este es un arreglo de bits que tiene
en Ci un 0 si la iniciación es libre y un 1 si es prohibida en el ciclo i ( 0 si i pertenece a F’ y 1 si pertenece
a F). La longitud del vector es n, donde n = máx { Fi } por tanto, Cn = 1 siempre es verdad. Formalmente:
C = (Cn . . . C1) donde Ci = 1  i  F  Ci = 0  i  F’
En nuestro caso: C = ( 10110001)
Nótese que la nomenclatura empleada no es la de un vector matemático sinó la de un registro binario.

Esto tiene su razón, en realidad la estrategia de control se implementa en un registro de desplazamiento
por la derecha. Al iniciar el cauce por primera vez, se carga el vector de colisiones en el registro y en
cada ciclo se desplaza un bit a la derecha, así sólo se inicia una nueva tarea en el ciclo k si la salida
serial del registro es 0. El registro se recarga con C cuando la latencia es n.
Para caracterizar la dinámica de las iniciaciones sucesivas en el cauce, se emplea un diagrama de estado
que tiene por estado inicial a C. Para construir dicho diagrama de estados se simula que se inició una
nueva operación en el cauce para cada latencia permitida o libre (para cada latencia libre k, se hace un
Página 52
desplazamiento de k posiciones del estado simulando los k ciclos de reloj que han transcurrido, para
obtener el valor del vector de colisiones en ese momento y aplicando un OR binario con el vector de
colisiones original C, a fin de limitar las latencias prohibidas). Si el valor resultante es diferente a los
estados anteriores, se tiene un nuevo estado.
Una vez que se realizan las simulaciones de iniciar una nueva operación para todas las latencias
permitidas de todos estados, se puede construir el diagrama de estados como un grafo, representando
cada estado como nodos de éste. Las transiciones de un estado a otro se representan como arcos cuya
etiqueta muestra cuántas latencias (desplazamientos) se requieren para llegar a ese estado.
Para el ejemplo de la tabla de reservas mostrada:
▪ Partiendo del vector de colisiones o Estado 1, para las latencias permitidas (2, 3, 4 y 7) simulamos se
inicia una nueva operación. Para la latencia permitida 2: desplazamos 2 posiciones a la derecha y
enmascaramos con C mediante OR:
00101100
(OR) 1 0 1 1 0 0 0 1
10111101 → Estado 2 ( con latencia 2)
▪ Obtuvimos un valor diferente al estado 1 por lo que lo nombramos estado 2. De manera similar, para las
latencias 3 y 4, desplazando 3 y 4 posiciones y aplicamos OR con C, obtenemos nuevos estados 3 y 4.
00010110 00001011
(OR) 1 0 1 1 0 0 0 1 (OR) 10110001
1 0 1 1 0 1 1 1 → Estado 3 1 0 1 1 1 0 1 1 → Estado 4
(con latencia 3) (con latencia 4)
▪ Finalmente, para la latencia 7, desplazando 7 posiciones y aplicando OR con C, se regresa al estado 1:
00000001
(OR) 1 0 1 1 0 0 0 1
1 0 1 1 0 1 1 1 → Estado 1 (con latencia 7)
▪ Luego, pasamos al estado 2 y simulamos para cada una de sus latencias permitidas (2 y 7). Para la
latencia 2 se genera el estado 5. Para latencia 7 se retorna al estado 1:
00101111 00000001
(OR) 1 0 1 1 0 0 0 1 (OR) 1 0 1 1 0 0 0 1
1 0 1 1 1 1 1 1 → Estado 5 1 0 1 1 0 0 0 1 → Estado 1
( con latencia 2) ( con latencia 7)
▪ Del estado 3 las latencias permitidas son: 4 y 7. Con latencia 4 se llega al estado 4. Con latencia 7 se
retorna al estado 1:
00001011 00000001
(OR) 1 0 1 1 0 0 0 1 (OR) 1 0 1 1 0 0 0 1
1 0 1 1 1 0 1 1 → Estado 4 1 0 1 1 0 0 0 1 → Estado 1
Página 53
▪ Del estado 4 las latencias permitidas son: 3 y 7. Con latencia 3 se llega al estado 3. Con latencia 7 se
retorna al estado 1:
00010111 00000001
(OR) 1 0 1 1 0 0 0 1 (OR) 1 0 1 1 0 0 0 1
1 0 1 1 0 1 1 1 → Estado 3 1 0 1 1 0 0 0 1 → Estado 1
▪ Del estado 5 solo se permite latencia 7. Con latencia 7 se retorna al estado 1:
00000001
(OR) 1 0 1 1 0 0 0 1
1 0 1 1 0 0 0 1 → Estado 1 (con latencia 7)
Habiendo realizado la simulación de todas las inicializaciones de operaciones posibles en el cauce para
todas las latencias permitidas, se obtienen cinco estados y las posibles transiciones entre los mismos con
lo cual se puede construir el diagrama de estados, que se muestra en la figura 2.6.7.
7+
1
7+
10110001 7+
7+
7+ 3 4 2
3 2
10110111 10111101
3 4 4 2
5
10111011 10111111
Figura 2.14. Diagrama de estados
Los ciclos en el diagrama muestran las secuencias de latencias sostenibles de régimen permanente sin
colisiones.
Se denomina ciclo simple a aquella trayectoria que no repite estado excepto el origen-destino. La
latencia media de un ciclo es la suma de las latencias de un ciclo entre la cantidad de ellas. La máxima
productividad se logra en una secuencia que involucre ciclos con la mínima latencia media (mlm), el
número máximo de repeticiones de etapa (cantidad máxima de x en una fila de la tabla de reserva) es la
cota inferior a la mlm.
Un ciclo simple es avaricioso si cada latencia en el ciclo es la mínima de cada estado por el que pasa
(verificar arcos salientes) y su latencia media es menor o igual al número de latencias prohibidas y mayor
o igual a la mlm. Una buena estrategia de control involucra ciclos avariciosos.
Página 54
A continuación, se resumen los resultados para nuestro ejemplo:
Ciclo simple Latencia media Avaricioso

(7) 7
( 3, 7 ) 5
( 3, 4 ) 3.5 SI, tiene la mlm
( 4, 3, 7 ) 4.6
( 4, 7 ) 5.5
( 2, 7 ) 4.5
( 2, 2, 7 ) 3.6 SI
( 3, 4, 7 ) 4.6
La mejor estrategia de régimen para este cauce es el ciclo (3, 4), es decir, iniciar una operación, esperar
3 ciclos para iniciar la siguiente, luego esperar 4 ciclos para iniciar la tercera, luego, esperar 3, luego 4
y así en lo sucesivo. De esta forma se obtiene la menor latencia media entre operaciones y por tanto, la
mejor eficiencia del cauce.
Otra opción podría ser alternar con el ciclo (2, 2, 7), que es también avaricioso.
Página 55
3 ARQUITECTURAS SIMD
3.1 INTRODUCCIÓN
3.1.1 Necesidad de Procesamiento Vectorial
A finales de los 50 e inicios de los 60, se incrementó la demanda de procesamiento automatizado

para cálculos científicos. Estos requieren procesar vectores y matrices, a menudo de gran
tamaño.
Un gran inconveniente surgió con los modelos secuenciales de la época, pues las arquitecturas
y lenguajes de programación secuenciales tienen un desempeño muy pobre en este tipo de
operaciones, que regularmente se simulan mediante ciclos, obteniendo tiempos de respuesta
prohibitivos para la mayoría de las aplicaciones requeridas.
Un ejemplo claro es la multiplicación de matrices que involucra tres ciclos anidados con lo cual
cada incremento de las dimensiones multiplica los ciclos por dos factores, lo que nos resulta en
un algoritmo exponencial del orden O(n3):
t FOR I = 1 TO N
FOR J=1 TO M
C [I, J] = 0.0
FOR K=1 TO L
C [I, J] = C [I, J] + A [I, K] * B [K, J]
END FOR
END FOR
ENDFOR
n
La necesidad, impulsó a los diseñadores de computadoras a tratar de interpretar de mejor

manera el comportamiento de estas estructuras de datos. Para ello se consideró útil hacer un
análisis de las características del procesamiento de vectores y matrices, y sus exigencias. El
resultado fue un conjunto de máquinas de alto coste, desempeño y una enorme capacidad de
cálculo (que varía de máquina a máquina) las que asignaremos a la clasificación SIMD de la
taxonomía de Flynn (aunque algunos autores señalan que solo un espécimen de la familia: el
processor array es SIMD puro).
3.1.2 Características y exigencias del procesamiento de Vectores / Matrices
Características:
• Colección o arreglo de datos.
• Se almacenan en celdas contiguas en la memoria.
• Independencia de datos (operación en elemento [i, j] no depende de resultado en
[i-1, j-1]).
Página 56
• Una misma operación sobre todo el conjunto de datos.
Exigencias:
 Diferentes tipos de operaciones
o f1: V → V (VSQRT, VCOMP –complemento, VSIN, VCOS )
o f2: V → E (VSUM –Sumatoria de elementos, VMAX, VMIN)
o f3: V x V → V (VADD, VMP –Multiplicación de vectores o matrices)
o f4: V x E → V (SMUL – Escalación del vector, SADD –Desplazamiento)
o f5: V x V → E (SMP –Producto punto de vectores)
 Manejo de operandos vectoriales y escalares (Instrucciones de máquina vectoriales o

vectorización por compilador)
 Algoritmos idóneos
 Ejecución a alta velocidad
3.2 Tipos de Arquitecturas SIMD
3.2.1 Procesadores vectoriales o Vector Processors
 Las características y exigencias del procesamiento vectorial son propias para la ejecución
segmentada, básicamente porque se eliminan las dificultades de la segmentación (no riesgos
estructurales, de datos o control) permitiendo tener el cauce lleno y generando resultados a par
de elementos por ciclo.
 Obviamente surgen nuevas exigencias en cuanto al flujo de datos de entrada y la recepción de

salida.
 Los procesadores vectoriales son arquitecturas que implementan cauces para procesamiento de
vectores.
Página 57
3.2.2 Procesadores matriciales o Array Processors
Los procesadores vectoriales, requieren

diferentes esquemas de ejecución cuando procesan
matrices.
Un enfoque más acertado consiste en tener una red

o matriz de procesadores o unidades de ejecución
(EP) con registros y/o memoria local gobernados
por un procesador o unidad de control central.
Al ejecutar una instrucción, la unidad de control

emite a todos las mismas señales de control
(broadcast) sincrónicamente y los EPs ejecutan
todos la misma operación sobre sus datos locales.
3.3 Procesadores vectoriales Encauzados

(Vector Processors)
3.3.1 Cauces vectoriales
 Cauces aritméticos.
 Supercomputadores Vectoriales / Procesadores vectoriales Asociados
 Entradas: Vector –Vector o Vector-Escalar.
 Salida a Vector o Escalar.
 Requieren registros especiales para control de la longitud del vector.
 Formato especial de instrucción
 Esquemas o métodos de procesamiento para tratamiento de matrices
o Procesamiento horizontal (filas: izq → der)
o Procesamiento vertical ( columnas: arriba → abajo)
o Procesamiento en bucle ( ciclos de sub-matrices )
 Tiempo de retardo de inicialización o preparación del cauce y de paso o flushing.
 Entrada de datos/Recepción de salida a alta velocidad.
o Desde Memoria (Requerido acceso rápido)
o Usar registros vectoriales
3.3.2 Maquinas M-M, Memorias entrelazadas y Procesamiento en flujo continuo
 Los operandos vectoriales residen siempre en memoria.

 Alto tiempo de preparación (típico ~20 cycles)
 Se requieren memorias de alta velocidad, ideal: entregar un par de datos y recibir un resultado
por ciclo.
 Uso de memorias entrelazadas. Este tipo de memoria permite acceso a múltiples módulos en
un mismo ciclo de búsqueda (el esquema de direcciones asegura que se seleccionan los n
módulos a la vez permitiendo acceder a n palabras a la vez) y entregar ráfagas de datos en n
ciclos consecutivos, por lo que permite ingreso de múltiples datos al cauce en cada ciclo de
reloj, habilitando el procesamiento en flujo continuo.
Página 58
 Alto rendimiento para vectores grandes.

 Formato requiere especificar direcciones en memoria de los vectores y en algunas máquinas
con palabras variables, el incremento o tamaño del elemento, así como el tamaño del vector.
COP V1 V2 Vr Incr Tam
3.3.3 Máquinas R-R y Encadenamiento de vectores.
 Empleo banco de registros vectoriales. (además del escalar)

 Carga de Memoria a registros de alta velocidad.
 Menor tiempo de preparación y en general menor ciclo de máquina que la M-M.
 Tamaño restringido de los registros vectoriales (64, 72, 128 elementos)
 Ejecución en partes para vectores largos: Alto desempeño en vectores pequeños y pobre en
largos.
 Predominan sobre las M-M.
 Formatos de instrucción usan directamente registros vectoriales / escalares (Instrucciones de
carga) o direcciones de memoria y registros a emplear. Algunos ejemplos:
COP RV1 RV2 RVr Tam
COP RV1 @V2 Incr Tam
 Enmascaramiento y vectores binarios.

 Usualmente tienen múltiples Cauces vectoriales (Unidades funcionales) y Escalares.
Página 59
CAUCE 1
UNIDAD DE
PROCESAMIENTO DE
INSTRUCCIONES BANCO DE CAUCE 2
(IPU) REGISTROS
ESCALARES
CAUCE n
Procesador
Escalar
CONTROLADOR DE
MEMORIA
INSTRUCCIONES
PRINCIPAL
VECTORIALES
Procesador
Vectorial
CAUCE V1
BANCO DE CAUCE V2
REGISTROS
VECTORIALES
CONTROLADOR DE
ACCESO VECTORIAL
CAUCE Vn
 Múltiples UF: Prefetch + Ejecución simultánea de varias instrucciones → Tratar potenciales

dependencias de datos (R-D)
 Encadenamiento de cauces: ejecución paralela de varias instrucciones con dependencia R-D.
3.4 Procesadores Vectoriales
3.4.1 Procesadores de arreglos de EPs.
 Arreglos de EPs.
 Verdaderas máquinas SIMD.
 Introducidas en los 70’s, auge en finales de los 80’s.
 Requieren gran estructura de EPs para ser eficientes.
 Tiempo de ejecución de la instrucción matricial fijo (vs te = n+p+fluss del Vector P. )
 Estructuras de interconexión - Comunicación EPs, Memoria y E/S: Topología.
 Memoria de alta velocidad para cargar las caches o registros de EPs.
Página 60
3.4.2 Enmascaramiento, limitando la estructura.
 Los EPs pueden Habilitarse o deshabilitarse desde la UC.

 Esto permite limitar la estructura para ajustarse al tamaño de la matriz.
 Equivalente a control de tamaño de vector en VPs.
3.4.3 Importancia de VLSI en las Arquitecturas SIMD.
 VLSI permite integración de alta densidad

 Ejemplo: MasPar MP-1: Processor Board: 32 chips de 32 MP-1 con su 64Kb memoria y control
en 4 pies cuadrados. Se puede configurar en redes de n x n o de n x 2n. La mínima
configuración involucra 1,024 procesadores y la máxima 16,384.
3.5 Procesadores Sistólicos
3.5.1 Deficiencias de la taxonomía de Flynn.
Existen arquitecturas paralelas que no caben en la Taxonomía de Flynn. Paradójicamente,

mientras por un lado, existe vacuidad en una categorización, por otro hay ambigüedad en la
posible clasificación de algunas máquinas.
Algunos autores, apegados al sentido estricto de Instrucción, declaran vacía la clasificación

MISD, en tanto otros, que se basan en las operaciones que se aplican en el procesamiento del
data stream más que en la instrucción completa en sí, identifican a los cauces aritméticos como
arquitecturas de esta categoría. También los arreglos sistólicos que estudiaremos en seguida son
a menudo clasificados en este grupo.
Por otro lado, aunque algunos asumen que el VP es SIMD (punto de vista de la instrucción),
otros los clasifican como simples SISD por cuanto la operación se aplica de forma repetida al
conjunto de datos en diferentes instantes de tiempo.
Los MIMD están todos agrupados en una categoría única que reúne máquinas de muy diferente
potencia de cálculo, complejidad de diseño y coste.
Finalmente, se ha propuesto un estilo de computación sobre una arquitectura multiprocesador

que ejecute el mismo programa sobre diferentes conjuntos de datos y que los Procs. se
sincronicen peródicamente (Para tal estilo de computación se ha propuesto la categoría Single
Program Multiple Data)
3.5.2 Arreglos sistólicos
 Concepto introducido por Kung y colegas (Carnegie-Mellon)
Página 61
 Sistólico porque la memoria funciona como el corazón, inyectando datos al arreglo en

cada pulso de reloj
 Consigue mejoras de procesamiento sin necesidad de incrementar el ancho de banda
de la memoria
MEMORIA MEMORIA
P EP EP EP EP
Procesador convencional Matriz Sistólica
 Cauce en formación matricial con múltiples flujos de datos.

 Conjunto de celdas simples (Unas sola operación con entradas y Registro).
 Control e interconexión simples (No Broadcasting)
 Datos fluyen de forma encauzada, estructurada y son accesibles sólo en las fronteras.
 Interconexión en matriz o árbol.
EP EP
EP EP EP
EP EP
EP EP
EP EP EP EP EP EP
EP EP
EP EP EP EP EP EP EP
EP
Matriz Cuadrada Matriz Hexagonal Arbol sistólico
 Aritmética Matricial de alto nivel: Multiplicación, Inversión, Desc, L-U

 Fácil de expandir (VLSI simple)
 Desventaja: Limitado por la velocidad de E/S
Ejemplo de un Procesador sistólico (De Rafiquzzaman – Pág. 312).

X0
X
0 0 0
W2 W1 W0
Z=W*X+Y
Y
W
2 1 0
Fig 1: Celda EP del procesador Fig 2: Estructura de Interconexion del

sistolico Procesador sistolico
3.6 Procesadores de Frente de Onda
Página 62
3.6.1 Redes sincrónicas vs. redes asíncronas
 Los AP: Broadcasting síncrono. Requieren Memorias de alta velocidad.

 Matrices asíncronas: Proceder hasta que el dato esté disponible. → Esperar a memoria.
3.6.2 WaveFront Array Processor
 Celdas simples y comunicación simple

(similar al sistólico).
 Cuando hay datos válidos en las entradas, la B21 B22
celda de dispara (computa) y expande el
B11 B12
resultado a las salidas.
 Recibe su nombre por analogía con los frentes
de onda ( sonido, perturbación en agua, etc)
A12 A11 0 0
A22 A21 0 0
3.7 Procesadores Asociativos
3.7.1 Procesadores Asociativos
 Procesadores paralelos basados en estructuras de datos asociativas (Memorias

asociativas, por lo general)
 Su nivel de paralelismo se mide en bit-{serie|paralelo},palabra-{serie|paralela}
 Aplican la misma instrucción sobre todos los datos cuya clave satisface los parámetros
o argumentos de búsqueda.
 En la actualidad estas arquitecturas han dado pie a nuevos paradigmas
computacionales con soporte de hardware para bases de datos y aplicaciones que
demandan procesamiento paralelo de conjuntos de datos.
3.7.2 Ejemplares
Primeros: PEPE (Burrogs Corp., 1972) y STARAN (Goodyear, 1972. Construído para la
Marina USA, orientado al procesamiento de objetos de radar). Posteriormente:
procesadores asociativos masivamente paralelos para apoyo en campos y aplicaciones
específicos tales como RDBMS (RAP, Neocore LCC) e Inteligencia Artificial (AM3,
IXM2).
3.8 Estructuras y algoritmos para Procesadores Matriciales.
Página 63
3.8.1 Estructuras de Interconexión – Comunicación EPs.
 Necesaria una estructura que interconecte todos los EPs.

 Decisiones de diseño:
o Modo de operación: Sincrónica – Asíncrona
o Estrategia de Control: Centralizado o Distribuido.
o Metodología de Comunicación: Conmutación de Circuitos o Conmutación de
Paquetes.
o Topología de Red: Estáticas – Dinámicas
3.8.2 Características de los Algoritmos matriciales.
 Complejos
 Reproducen el comportamiento natural de la estructura de dato
 Ganancia significativa sobre homólogo secuencial
Ejemplos:
o Multiplicación de matrices.
▪ Secuencial es O(n3)
▪ Con vectores: O(n2) Carga de vectores, barrer filas por columnas.
- Ganacia es n.
▪ Con SIMD con hipercubos: O(n log2 n)
- Ganacia poco más que n
▪ Con SIMD y Computación VLSI : O(n)
- Ganacia n2
o Clasificación O(n) vs. O( n log2 n) de los secuenciales.
o Transformada rápida de Fourier FFT, ganancia es M2/log2
Página 64
4 ARQUITECTURAS MIMD.
4.1. Introducción a los MIMD: Multiprocesadores
Un Sistema Multiprocesador puede definirse como una comunidad de procesadores en

la misma computadora que cooperan para completar una tarea.
Por otro lado, es necesario hacer notar que aunque un sistema común usa un IOP o una FPU
que son en sí procesadores, estos no se consideran Multiprocesador por cuanto cada uno de los
procesadores auxiliares tiene una sola tarea específica y no son capaces de ejecutar programas
del usuario.
Con los sistemas multiprocesadores:
 Puede hacerse múltiples trabajos en paralelo

 Puede dividirse un trabajo en múltiples tareas paralelas
Concepto: Sistema que consta de 2 o más CPU interconectadas para permitir la ejecución de
múltiples tareas en paralelo. (n instrucciones en n procesadores ejecutándose a la vez)
Nivel de Paralelismo o granularidad:
Cuatro niveles de paralelismo:
 Nivel de tareas (Job Level): Diferentes procesos son asignados a diferentes

procesadores. Incluso se pueden asignar hilos de ejecución de un mismo proceso a
diferentes procesadores. A este nivel se le denomina de Granularidad gruesa. En este
nivel el control de la asignación de los procesos o los hilos de ejecución es asumido por
el sistema operativo.
 Nivel de Programa (Program level): Cuando diferentes procesadores pueden ejecutar

diferentes secciones de un mismo programa en paralelo. Existen varias posibilidades:
Rutinas completas, tramos de instrucciones independientes y diferentes iteraciones de
un ciclo sobre datos independientes (como matrices, por ejemplo). Este nivel se
considera de Granularidad fina. Es importante notar que en este caso es frecuente tener
datos compartidos. La asignación paralela de los tramos de programa en este caso los
puede definir el compilador, el programador a bajo nivel y el sistema operativo. (En
algunos sistemas MP, el programador o el compilador pueden definir explícitamente
que una rutina, conjunto de instrucciones o cada simple instrucción se ejecute y en
diferentes procesadores, es más, se puede definir inclusive en qué procesador se desea
la ejecución de ésta. Este enfoque tan fino no siempre es ventajoso porque atenta contra
una de las bondades de los MP: redundancia que permite gracefull degradation)
 Nivel de instrucciones (Instruction Level): Este nivel es más intimo a la organización

del procesador y ocurre en el caso específico de los procesadores encauzados, donde la
Página 65
ejecución de varias instrucciones se efectúa en diferentes etapas del procesador de forma

solapada en el tiempo (Granularidad más fina).
 Nivel de Aritmética y bits. (Bit Level): En este nivel, el paralelismo se verifica a nivel
aritmético, es decir, tenemos varios procesadores trabajando en paralelo sobre diferentes
secciones de bits de los datos en sí (especie de SIMD a nivel de bits) Este tipo de
procesadores se compone de enlaces de varios bit-slice processors. (Nivel de más fina
granularidad)
Para el caso de los sistemas MP, son comunes los dos primeros niveles de paralelismo. La figura
a continuación ilustra el caso del primer nivel comparando un sistema monoprocesador y uno
MP con procesos:
P P1 P2 P3
Pr
Pr Pr
Pr
Pr
Pr
Pr Pr
Sistema Sistema
Monoprocesador Multiprocesador
4.1 Clasificación de los sistemas MIMD.
• Sistema Fuertemente Acoplado o de M Compartida (Reales MP según Bell).

• Sistema Débilmente Acoplado, de Memoria distribuída o Multicomputadores (según
Bell).
La principal diferencia estriba en cómo se interconectan. Para que puedan compartir la

memoria, se requiere una estructura de interconexión fuertemente acoplada, como por ejemplo
un bus común. Otra principal diferencia es cómo intercambian información y cómo están
controlados o sincronizados.
- Los primeros son más fáciles de construir y pero presentan limitaciones respecto a la cantidad
de procesadores concurrentes: Problema del ancho de banda de los MP con memoria común:
 Implementar memoria local en los “processing environments” o cachés.
 Mencionar problemas de diseño con cachés MP: política de escritura (write through
vs write back) y coherencia.
4.2 Estructuras de Interconexión.

Exponer el concepto de Estructura de Interconexión.
Hacer referencia y remembranza de los requerimientos señalados en las SIMD.
Página 66
4.2.1 Bus común.
La manera más sencilla de interconectar varios CPUs con una Memoria común (que puede estar
formada por varios bancos a la vez)
es mediante un Bus común. Esto
permite tener algunos IOPs también. P1 P2 P3 P4
El problema grande de este
acercamiento es eque la memoria se
convierte en cuello de botella,
requiriendo gran ancho de banda en
el acceso a memoria o limitando la
cantidad máxima de contendientes M1 M2 IOP IOP
por el bus. Una medida paliativa
muy eficaz consiste en definir una
jerarquía de memoria de al menos
MIMD con Estructura de interconexión
dos niveles. Muchos MP de
memoria compartida suelen emplear empleando Bus común
pequeñas memorias locales además
de uno o dos niveles de cache.
El uso de una memoria compartida de gran tamaño, organizada en bancos o módulos, también
puede aprovecharse para “paralelizar” el acceso a la memoria mediante entrelazamiento,
permitiendo un acceso “encauzado” a la memoria. Otra solución a la necesidad de ancho de
banda consiste en el ensanchamiento del ancho del bus de datos para permitir mayor velocidad
de transferencia hacia las cachés. También puede crearse puertos a cada banco con lo cual
podría accederse en paralelo a diferentes módulos de la misma Memoria principal o mejor aún,
múltiples accesos al mismo módulo. En los siguiente párrafos veremos cómo se han
aprovechado estas posibilidades mediante nuevas estructuras de interconexión.
Página 67
4.2.2 Conmutador Barra-Cruz.
Otra manera de interconectar los CPUs con la memoria, si ésta es modular, consiste en
emplear una estructura de interconexión en forma de una malla de conmutación de circuitos.
La figura muestra un conmutador barra-cruz típico.
Existen buses de conexión de cada

procesador a cada módulo de memoria. En las
intersecciones de las barras o buses, existen
conmutadores capaces de unir una barra
horizontal con una vertical creando un bus
particular entre el procesador y el módulo. En
cualquier instante cualquier procesador puede
adquirir acceso a un módulo que no esté
ocupado por otro procesador. En el caso que dos
procesadores deseen acceder al mismo módulo al mismo tiempo, éstos se bloquearán
mutuamente. En ese caso uno tendrá que reintentar luego. Para lograr este objetivo, se
implementan políticas de arbitraje que definen cual procesador tiene prioridad en caso de
bloqueo.
4.2.3 Memorias Multipuerto
Aunque el enfoque sencillo del M1 M2

conmutador barra-cruz es muy simple y
relativamente de bajo costo, las políticas de
arbitraje pueden hacerlo complejo o ineficiente. P1 IOP
En arquitecturas más demandantes se

han diseñado memorias que permiten n accesos
concurrente, para lo cual están provistas de n P2 IOP
puertos de acceso. La figura muestra este
esquema de conexión. Estas memorias son muy
ventajosas en caso de pocos CPUs y casi P3
inviables cuando la cantidad de puertos
requeridos crece. De hecho, no son escalables,
es decir, que la cantidad de CPUs del MP está
limitada a los puertos disponibles en las P4
Memorias.
MIMD con Estructura de interconexión
Como todo elemento que permite mediante Memorias Multipuerto
interconexión completa, su costo es muy
elevado.
Página 68
4.2.4 Redes Interconexión multietapa.
Las estructuras de interconexión anteriores son relativamente simples. Heredando de las

SIMD, algunos diseñadores de MPs han empleado redes de conmutadores para interconectar
CPUs y Módulos de memorias. Estas redes deben garantizar el acceso único a un módulo en
cualquier momento (arbitraje) para evitar race conditions y por tanto se diseñan como redes de
múltiples etapas. Los nodos de estas redes son dispositivos de conmutación denominados
conmutadores de intercambio. La figura a continuación muestra la estructura de un conmutador
de intercambio. Estos permiten en cualquier momento enrutar cualquiera de sus entradas a
cualquiera de sus salidas que no se encuentre ocupada. Otra vez, se debe definir la prioridad de
cada entrada. Se emplea un bus de control de 1 bit asociado a cada entrada, que indica la salida
a la que queremos conmutar.
La figura abajo muestra un tipo de red multietapa denominada red delta, por su forma
triangular. Otras redes más complejas permiten caminos alternativos a módulos que no han sido
ocupados. Por ejemplo la red omega. (Investigar la red omega). En cada red multietapa, existen
parámetros que se pueden calcular para poder definir de antemano: cantidad de Conmutadores,
etapas y enlaces necesarios, de acuerdo a la cantidad de CPUs y Módulos de Memoria.
4.2.5 Hipercubo.
Esta red se aplica mayormente a MPs de memoria distribuida y a algunos SIMD. Es una
red de conmutación de paquetes. En este caso, los nodos de la misma no son conmutadores sino
CPUs con su memoria local e inclusive I/O propia. El hipercubo es una red eficiente y escalable.
Presenta algunos retos al diseñador como la asignación de direcciones para los CPUs. Las
direcciones se asignan en forma de cadenas de bits. Un principio establece que dos nodos
contiguos solo diferencian su dirección uno del otro en 1 bit. Esto permite establecer algoritmos
de asignación de direcciones sencillos así como algoritmos de enrutamiento de paquetes o
mensajes. La figura abajo muestra la construcción escalable de hipercubos de 1 a 4 dimensiones.
Página 69
4.3 Acceso a recursos compartidos
En los MPs ce memoria compartida, existen obviamente, problemas de concurrencia:

 Estructura de interconexión: Se emplean métodos de arbitraje.
 Acceso a regiones y estructuras de memoria compartidas: Es necesario sincronización
de regiones críticas: Acceso exclusivo de los recursos. Uso de gates, pinlocks y
semáforos.(ver exclusión mutua)
4.3.1 Arbitraje del bus
La Arquitectura de bus común es muy sencilla y de bajo costo. Requiere acceso exclusivo,
durante un período de tiempo, por tanto se requiere Arbitraje: lógica y controlador que
concede el bus a un dispositivo específico:
Arbitraje fijo: Arbitraje paralelo (Codificador/Decodificador de prioridades)
Arbitraje serial (Cadena de margaritas)
Arbitrio dinámico: Estructura dinámica y/o algoritmo.
• Otras estructuras de interconexión tienen sus propios esquemas (revisar barra-cruz, red
multietapa, etc)
4.3.2 Exclusión mutua
Concurrencia de ejecución → acceso a estructuras de datos y SO que son compartidas. Para

garantizar la coherencia → acceso debe ser mutuamente excluyente. Soporte por SO y Hw:
• Gate o puerta: Puerto de acceso a una estructura compartida.

• Semáforo: Indicador de acceso.
Página 70
• Pinlock o seguro: Componente Hardware que garantiza TEST&SET atómico.
4.4 Comunicación entre Procesadores
• Es necesario definir formas de comunicación y sincronización de Procesadores en un

sistema MP.
• Uso de puertos de E/S
• En un MP de memoria compartida, se puede emplear un área de memoria como

exchange de mensajes. Cada MP puede poner mensajes, procedimientos o solicitudes
a otros o chequear si tiene nuevas solicitudes o mensajes dirigidos a él, para esto se usa
polling de Bits de estado que indican el contenido del buzón, de forma periódica.
• Una mejora consiste en el uso de Interrupciones entre procesadores.(por programa)
• Uso de un bus alternativo al bus del sistema.
En MP débilmente acoplados, la comunicación mediante la red: E/S. Paso de Mensajes:

 Se enrutan mensajes.
 Importante, la eficiencia de la red.
4.5 Coherencia de cachés
En sistemas de bus común, el tráfico y el cuello de botella debido al mismo en el bus, se puede
aliviar significativamente con el uso de cachés. La concurrencia impone altos requisitos a estas
cachés. El principal de ellos es resolver el problema de la coherencia de caché.
Escenario: Varios procesadores ejecutan hilos de un código reentrante que comparte algunas
variables globales. Estas variables son accedidas y actualizadas por todos los procesadores.
Cada vez que un procesador actualice, los demás deben tener noción de ello, pues las copias
quedan incoherentes entre sí.
Existen varios métodos o protocolos de solución de este problema:
En el primero, se resuelve la situación evitando el problema. El algoritmo estático,

implementado por compilador, asigna el acceso para actualizar a un dato compartido a un solo
procesador en un momento dado, por lo cual, no ocurre el problema.
En el segundo bloque se encuentran varios protocolos de “sondeo” o snoopy protocols, que

permiten a encuestar los estados de los procesadores antes de realizar la actualización.
Página 71
• Uso de un bit de bandera (dirty bit). Cada vez que un procesador va a actualizar su copia,
pone en 1 un bit e interrumpe a los otros para que no actualicen su copia hasta que el
concluya su trabajo, en cuyo caso aquellos sondean el bit periódicamente hasta que el
primero actualiza la M, y el resto refresca su copia. Este esquema se emplea con política
write through y genera bastante tráfico en el bus.
• El segundo esquema, llamado MESI, permite tener perfecto control de los estados de
la caché mediante un diagrama de estados que se va generando dinámicamente en el
funcionamiento de la caché. Revisar en Stallings detalles.
4.6 Sistemas Operativos y lenguajes de programación MP
4.6.1 Sistemas operativos:
SO para MP debe estar específica y especialmente diseñado para administrar esa arquitectura.
• Administrar la concurrencia
• Manejar la exclusión mutua
• asignación de recursos y tareas
Modelos de asignación de recursos (lo hace el SO)

Master-Slave
SO separados
SO Distribuido o flotante
Para garantizar graceful-degradation, un sistema de diagnósticos es imprescindible (muchas

veces es un procesador auxiliar). Esto se implementa tanto en el arranque como en tiempo de
ejecución.
4.6.2 Lenguajes:
Varias formas de explotar el paralelismo:
• Dejarle el trabajo al OS.

• Lenguajes y compiladores que permiten paralelización de los programas secuenciales.
• Lenguajes y compiladores que permiten al usuario escribir código con instrucciones
paralelas.
Página 72

Folleto AMC3 2023

Cargado por

Información del documentohacer clic para expandir la información del documento

Copyright:

Formatos disponibles

Folleto AMC3 2023

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Folleto AMC3 2023

Cargado por

Copyright:

Formatos disponibles

Ier Sem

UNIVERSIDAD NACIONAL DE INGENIERIA

DEPARTAMENTO DE ARQUITECTURA Y SISTEMAS

Folleto de apoyo al estudiante

José Leónidas Díaz Chow

Última modificación: mayo de 2023

1 PARALELISMO Y MEJORA DEL RENDIMIENTO ..... 1

2.5 DIFICULTADES DE LA SEGMENTACION........................................................... 29

3 ARQUITECTURAS SIMD ............................................ 56

3.4.2 Enmascaramiento, limitando la estructura. .......................................................... 61

4 ARQUITECTURAS MIMD. .......................................... 65

1 PARALELISMO Y MEJORA DEL RENDIMIENTO

El poder valorar el desempeño de un sistema de cómputo es necesario en diferentes escenarios,

Para poder cuantificar el rendimiento, necesitamos determinar los atributos, características o

Tabla 1.1. Cuadro comparativo de características de algunos aviones.

Capacidad Alcance Velocidad Productividad

Boeing 737 - 100 101 630 598 60,398

De manera análoga, el desempeño de un computador puede tener diferentes medidas de elección

1.1.1 Medida de rendimiento

La medida del rendimiento de interés en la computadora es el tiempo. Sin embargo,

1.1.2 Métricas de desempeño

Para poder evaluar el desempeño de un sistema de cómputo y poder comparar dos

• Latencia o tiempo de respuesta.

La productividad o throughput () como métrica de rendimiento, es la cantidad de trabajos o

1.1.3 Consideraciones de efectividad-costo

En la evaluación de computadoras, sobre todo con fines económicos o financieros, también se

Quizás el mayor trabajo para el arquitecto o diseñador consiste en alcanzar el mayor

1.1.4 Técnicas de análisis de desempeño

Las técnicas de análisis del desempeño de la ejecución de computadoras se pueden clasificar en

• Medición del desempeño (benchmarking)

Las técnicas analíticas y de simulación, requieren la construcción de un modelo: una

La tercera técnica, medida de la ejecución, no usa modelos, pero en cambio se sustenta en la

Dado que la medida de rendimiento es el tiempo, y que a menor tiempo de ejecución

Ra > Rb  1 > 1  ty > ta

– El rendimiento de A es 1,5 veces el de B.

O mejor aún, en qué porcentaje la una supera a la otra:

Así el incremento porcentual del rendimiento de X sobre Y, puede expresarse como:

1.1.6 Factores que determinan el tiempo de ejecución

Los factores que inciden en el tiempo de ejecución de un programa son: la frecuencia f

fb = (1.2 * 10s * 100MHz) / 6s = 200 MHz

1.1.7 Ley de Amdahl

Hemos obtenido expresiones que nos permiten relacionar el rendimiento de dos

“La aceleración de rendimiento global neta obtenida de incorporar una mejora a un

Ag = Rmejorado / Roriginal = toriginal / tcon mejora

tg = ttramo en que la mejora es efectiva + ttramo sin mejora

Ag = 1 / 0.4 + (0.6/2) = 1/ 0.7 = 1.43

1.1.8 Cálculo del tiempo de Ejecución

Donde ci es la cantidad de ciclos de la i-ésima instrucción, y N es el total de instrucciones

Donde nj representa la cantidad de instrucciones del j-ésimo grupo y cj es la cantidad de ciclos

En algunas arquitecturas, incluso es permisible hacer:

Siendo ci la cantidad de ciclos de la instrucción i-ésima del conjunto de instrucciones I de la

Donde CPI es la cantidad de ciclos por instrucción, N es el total de instrucciones ejecutadas, 

1.1.9 Métricas populares de rendimiento

Se han propuesto una serie de indicadores de rendimiento populares en el intento de crear

Una métrica muy difundida es la “velocidad o frecuencia de ejecución de instrucciones” que es

similar, si el repertorio de instrucciones de ambas máquinas difiere, es posible que el resultado

1.1.9.2 MIPS relativos

O punto_ flo tan te