Segmentación

Capítulo 2: Segmentación
Ganancias, productividad, fijar CLK
1 (Ejercicios de clase)
Un circuito que implementaba una operación en T op=450 ns. se ha segmentado mediante
un cauce lineal con cuatro etapas de duracción T1=100 ns., T2=125 ns., T3=125 ns., y
T4=100 ns. respectivamente, separadas por un registro de acoplo que introduce un
retardo de 25 ns. ¿Cuál es la máxima ganancia de velocidad posible? ¿Cuál es la
productividad máxima del cauce? ¿A partir de qué número de operaciones ejecutadas se
consigue una productividad igual al 90% de la productividad máxima?
Solución.
El cauce que se obtiene tendrá un tiempo de ciclo igual a
T = max {T1, T2, T3, T4} + retardo = max {100, 125 } + 25 = 150 ns.
Las expresiones de la ganancia, S(n), y la productividad, W(n), para n operaciones

ejecutadas en el cauce son
S(n) = Tsin_segmentación (n) / Tcon_segmentación (n)
W(n) = n / Tcon_segmentación (n)
donde
Tsin_segmentación (n) = n * Top = n * 450 ns.
Tcon_segmentación (n) = (Número_de_etapas * T) + (n-1) * T = 4*150+(n-1)*150 ns.
siendo el tiempo de latencia de inicio del cauce, TLI = Número_de_etapas*T= 4*150 ns
Sustituyendo en las expresiones de la ganancia y la productividad se tiene que
S(n) = (450 * n) / (600 + 150*(n-1))
W(n) = n / (600 +150*(n-1)) ns -1

por lo que haciendo tender n a infinito se tienen los valores de ganancia máxima y
productividad máxima:
Smax = 450 / 150 = 3 Wmax = 1 / 150 ns –1
El valor de n para el que se alcanza un 90% de la productividad se calcula despejando n

a partir de la igualdad
0.9 * Wmax = n / (600 + 150 * (n-1)) → n = 27 operaciones ejecutadas

Reorganización, Bypass y saltos.
Considere que el fragmento de código siguiente:
(1) lw r1,0x1ac
(2) lw r2,0x1fc
(3) add r3,r0,r0
(4) mult r4,r2,r1
(5) add r3,r3,r4
(6) add r5,r0,0x1ac
(7) add r6,r0,0x1fc
(8) sub r5,r5,#4
(9) sub r6,r6,#4
(10) sw (r5),r3
(11) sw (r6),r4
se ejecuta en un procesador segmentado con etapas IF (captación de instrucciones), ID

(Decodificación de Instrucciones/Captación de Operando), EX (Ejecución de
instrucción), MEM (ciclo de acceso a memoria/espera), OS (Almacenamiento de
resultados en el banco de registros). En la etapa de ejecución, una instrucción puede
utilizar una ALU para sumas/restas con enteros y operaciones lógicas (1 ciclo de
latencia), un sumador para operaciones en coma flotante (2 ciclos), un multiplicador (5
ciclos de latencia), o un divisor (19 ciclos de latencia).¿Cuántos ciclos tarda en
ejecutarse el programa anterior suponiendo que existe en el procesador segmentado
caminos de bypass que permiten el paso directo de resultados desde las salidas de los
circuitos aritméticos a sus entradas?. Indique las dependencias de datos entre
instrucciones que podrían tener efecto en el rendimiento del cauce (si no hubiese
caminos de bypass).
Solución.
El diagrama de ciclos correspondiente al código es el siguiente:
10
11
IF ID EX MEM OS
Se observa en el diagrama que se pierden 4 ciclos en los que no termina ninguna
instrucción debido a la dependencia de tipo RAW que existe entre las instrucciones (4) y
(5) respecto al registro r4, debido a que el resultado de la multiplicación (4) es el
operando de la instrucción (5), y la multiplicación tarda cinco ciclos en completarse. Por
ello, aunque haya varias unidades funcionales, que podrían aprovecharse en paralelo en
este caso (hay un multiplicador y un sumador en el cauce), la suma debe esperar a que
termine la multiplicación.
Si el tiempo de latencia del multiplicador fuese 1 ciclo, entonces no se perdería ningún

ciclo, gracias a que, con los caminos de bypass, los riesgos de tipo RAW no tienen
ningún efecto. En este caso, el programa tardaría en ejecutarse 15 ciclos, el mínimo
posible:
Tiempo=Tiempo de latencia de la primera instrucción + Un ciclo por cada instrucción

restante= 5 ciclos + (10 * 1) ciclos = 15 ciclos
Teniendo en cuenta que en este cauce las instrucciones terminan de forma ordenada, las
dependencias de datos que pueden afectar son las de tipo RAW: las WAW y WAR no
dan problemas porque al escribirse los resultados en el banco de registros sólo en la
última etapa, se puede estar seguro que en el momento en que escribe una instrucción,
todas las instrucciones anteriores han realizado sus escrituras, y por supuesto, sus
lecturas.
Para contabilizar las dependencias de tipo RAW se toman aquellas instrucciones que
estén separadas por menos (estrictamente) de dos instrucciones, ya que son las que
podrían estar simultáneamente en el cauce, y en donde la instrucción que entra en
primer lugar en el cauce puede escribir sus resultados después de que las que le siguen
vayan a leerlos (no se respetaría que la lectura ha de ser posterior a la escritura). Aquí se
está considerando que la escritura en el banco de registros en la etapa OS se realiza al
comienzo del ciclo, y que la lectura en dicho banco se hace al final del ciclo, ya que si
no fuera así, las instrucciones separadas por otras dos instrucciones sí que podrían
ocasionar pérdidas de ciclo en los riesgos RAW. Teniendo esto en cuenta, las
dependencias de tipo RAW que existen son:
- Instrucción (2) y (4) en r2

Considerando que no existen caminos de bypass (y que el tiempo de la multiplicación es

de 1 ciclo) se puede ver que el tiempo que tarda el programa es de 20 ciclos, es decir 5
más que el tiempo mínimo determinado antes. Estos cinco ciclos que se pierden se
explican de la siguiente forma:
- El RAW (2)-(4) ocasiona 1 ciclo perdido. Este ciclo perdido retrasa la captación
de (5) respecto a (3) y el RAW (3)-(5) no ocasiona pérdidas de ciclos.
- El RAW (4)-(5) ocasiona una pérdida de 2 ciclos.
- El RAW (6)-(8) ocasiona 1 ciclo perdido pero al retrasar la captación de (9)

respecto a (7) hace que el RAW (7)-(9) no afecte.
- Igual pasa con el RAW (8)-(10), éste ocasiona la pérdida de 1 ciclo, pero al
retrasar la captación de (11), hace que desaparezca el efecto del RAW (9)-(11).
(Se pueden comprobar los resultados simulando el programa mediante WinDLX).
Considerando el fragmento de código del problema anterior. ¿Cómo se podrían
reorganizar las instrucciones para que los riesgos de tipo RAW no tuvieran ningún
efecto cuando se utiliza un multiplicador con una latencia de cinco ciclos. (NOTA:
considere que intervienen los caminos de bypass)
Solución.
Pueden existir distintas formas de reorganizar el código para que los riesgos de tipo
RAW no tengan efecto. El objetivo es separar las instrucciones entre las que existían
riesgos de tipo RAW que producían pérdidas de ciclos utilizando otras instrucciones,
evitando que se introduzcan nuevos riesgos problemáticos, y lógicamente, sin cambiar
el resultado del programa.
En el caso que nos ocupa, se perdían 4 ciclos por el riesgo de tipo RAW existente entre
las instrucciones (4) de multiplicación (que duraba 5 ciclos) y la (5) de suma. Para
resolver el problema, una posibilidad es retrasar la instrucción (5), introduciendo entre
ella y la instrución (4) las instrucciones (6), (7), (8), y (9) ya que no dependen de la (5).
De esta forma, la instrucción (10) pasaría a estar a continuación de la (5) habría un
riesgo de tipo RAW (por r3). Si se utilizan caminos de bypass no se perderían ciclos,
pero, en cualquier caso, es posible reordenar (10) y (11) para que haya más seàración
entre (5) y (10). De esta forma, el código quedaría:
(1) lw r1,0x1ac
(2) lw r2,0x1fc
(3) add r3,r0,r0
(4) mult r4,r2,r1
(6) add r5,r0,0x1ac
(7) add r6,r0,0x1fc
(8) sub r5,r5,#4
(9) sub r6,r6,#4
(5) add r3,r3,r4
(11) sw (r6),r4
(10) sw (r5),r3
Al ejecutarlo, se puede observar que se necesitan 16 ciclos. Es decir, uno menos que el
valor mínimo, dado que aparece un riesgo estructural. En concreto, al mismo tiempo
que se termina la multiplicación, hay otra instrucción que se había metido en la unidad
de ejecución de enteros que también termina y, puesto que sólo una de las dos puede
pasar a la siguiente fase, habrá que detener una instrucción durante un ciclo. Esta
situación se puede comprobar en el siguiente diagrama:
En este ciclo no termina ninguna instrucción (la

2
multiplicación dura más de un ciclo)
7
Colisión:
terminan a la vez
8
11
10
Este resultado se puede comprobar mediante el simulador WinDLX. Si se realiza la

simulación suponiendo que no existen caminos de bypass se observa que el tiempo que
tardaría la ejecución es de 20 ciclos.
Se puede reducir un ciclo (similares prestaciones que en la situación inicial del

problema anterior, con el código sin reordenar y sin caminos de bypass) si se realiza la
simulación con el fragmento de código reordenado como se indica a continuación:
(1) lw r1,0x1ac
(2) lw r2,0x1fc
(6) add r5,r0,0x1ac
(4) mult r4,r2,r1
(7) add r6,r0,0x1fc
(3) add r3,r0,r0
(8) sub r5,r5,#4
(9) sub r6,r6,#4
(5) add r3,r3,r4
(11) sw (r6),r4
(10) sw (r5),r3
Realice un programa para calcular la expresión aX+Y, donde a es un escalar y X e Y son
dos vectores cuyos componentes se encuentran almacenados en memoria en posiciones
consecutivas a partir de dos direcciones establecidas. Además, tanto a como las
componentes de X e Y son números de doble precisión.
Suponiendo un cauce con las etapas IF, ID, EX, MEM, WB, y que la multiplicación
tarda 5 ciclos y la suma 2, y hay un multiplicador y un sumador que pueden trabajar en
paralelo, estime el número de ciclos que se necesitarían, y aplique alguna técnica que
permita reducir los atascos (stalls) para este programa.
Solución.
Un programa posible para realizar aX+Y es el que se muestra a continuación
start: ld f0,a (1)

add r8,r0,RX (2)
addi r4,r8,#512 (3)
add r12,r0,RY (4)
loop: ld f2,0(r8) (5)
multd f2,f0,f2 (6)
ld f4,0(r12) (7)
addd f4,f2,f4 (8)
sd 0(r12),f4 (9)
addi r8,r8,#8 (10)
addi r12,r12,#8 (11)
sub r20,r4,r8 (12)
bnez r20,loop (13)
nop (14)
donde RX y RY son las direcciones de memoria a partir de las que se encuentran,

almacenados los componentes de los vectores (8 bytes = 64 bits cada componente). En
el programa se ha fijado el número de componentes N = 64, por lo que el número de
bytes que componen el vector X (y lo mismo el vector Y) es igual a 64 x 8 = 512 bytes.
De esta forma, r8 apunta al comienzo del vector X tras la instrucción (2); r4 apunta al
final del vector X (primer byte no ocupado por las componentes del vector) tras la
instrucción (3); y r12 apunta al comienzo de Y tras la instrucción (4). En cada iteración
se va incrementando el valor de r8 y r12 en 8, ya que en cada iteración se hacen las
operaciones correspondientes a un componente, y cada componente tiene 64 bits (= 8
bytes). Para comprobar el final de las iteraciones se comparan r8 y r4.
1 2 3 4 5 6 7 8 9 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4
IF 1 2 3 4 5 6 7 7 8 9 9 9 9 10 10 11 12 13 13 5 6 7 7
ID 1 2 3 4 5 6 6 7 8 8 8 8 9 9 10 11 12 13 5 6 6
EX 1 2 3 4 5 6 6 6 6 6 8 8 9 10 11 12 13 5
7
ME 1 2 3 4 5 7 6 8 9 10 11 12 13 5
WB 1 2 3 4 5 7 6 8 9 10 11 12 13
Existen riesgos de tipo RAW que ocasionan pérdidas de ciclos, a pesar de que se
considere que se dispone de caminos de bypass:
- RAW entre la instrucción (5) y la (6): se pierde un ciclo debido a que la
multiplicación indicada en (6) no se puede empezar hasta que no se haya
captado de memoria el dato necesario, tras la etapa MEM de (5).
- RAW entre la instrucción (6) y (8), ya que no puede empezar la suma de (8)
hasta que no se haya terminado la multiplicación de (6)
- RAW entre (8) y (9), ya que hasta que no haya terminado la suma de (8) no
podría empezar la ejecución de (9).
- RAW entre las instrucciones (12) y (13), ya que se supone que, como en el caso
del procesador DLX, en la fase de decodificación de la instrucción de salto (13)
se debe haber ejecutado la instrucción anterior (12).
En la figura, los cuadros rallados corresponden a las etapas por las que iría pasando la
instrucción que se capta después de la de salto. Una posible forma de evitar los efectos
de una instrucción incorrectamente captada es, como en el caso del procesador que se
implementa en WinDLX, abortar la ejecución de toda instrucción captada tras una
instrucción de salto.
En la etapa EX del ciclo 10 de la figura se indican dos instrucciones: una se está

ejecutando en una unidad funcional (la multiplicación), y otra en otra unidad (la unidad
aritmética para enteros.
Por otra parte, obsérvese en la figura, que la instrucción (7) puede terminar antes que la
(6) dado que no existen dependencias entre ellas, y no afecta al resultado.
El tiempo de ejecución de una iteración es de 16 ciclos (desde que se capta la

instrucción (5) hasta que se vuelve a captar, tras la instrucción de salto). Así, si se
realizan N iteraciones, el tiempo consumido por el programa sería 16*N, pero a este
número hay que sumar, los 4 ciclos correspondientes a las instrucciones que están fuera
del bucle (al principio), más los 3 ciclos que hay que esperar para que termine la última
instrucción de salto a ejecutar. Por lo tanto, este programa tardaría:
T(N) = 7 + 16*N
Al simular el programa en WinDLX se obtiene que T(N=64) = 1031 ciclos,

coincidiendo con la fórmula anterior.
Una forma de mejorar las prestaciones del programa es desenrollar el bucle. En el

código que se muestra a continuación, se ha aplicado esta técnica de forma directa. Es
decir, se duplican las instrucciones de una iteración del bucle sin desenrollar, excepto la
instrucción de resta utilizada para determinar el final de las iteraciones.
start: ld f0,a (1)

add r8,r0,rx (2)
addi r4,r8,#512 (3)
add r12,r0,ry (4)
loop: ld f2,0(r8) (5)
multd f2,f0,f2 (6)
ld f4,0(r12) (7)
addd f4,f2,f4 (8)
sd 0(r12),f4 (9)
addi r8,r8,#8 (10)
addi r12,r12,#8 (11)
ld f6,0(r8) (5’)
multd f6,f0,f6 (6’)
ld f8,0(r12) (7’)
addd f8,f6,f8 (8’)
sd 0(r12),f8 (9’)
addi r8,r8,#8 (10’)
addi r12,r12,#8 (11’)
sub r20,r4,r8 (12)
bnez r20,loop (13)
En el código anterior los números de instrucciones (5’),..., (11’) designan a las

instrucciones correspondientes a (5),...., (11) en una iteración del bucle.
Para determinar el tiempo tardaría en ejecutarse el programa en este caso, se puede

utilizar el diagrama de etapas y tiempos utilizado anteriormente. En este caso, el tiempo
transcurrido entre que se capta la instrucción (5) y se capta la instrucción (12) es igual a
12 ciclos (17 – 5 =12). Como una iteración tiene dos secuencias similares de
instrucciones (5) – (11) y (5´) – (11’), se tendrán que contabilizar 2 x 12 ciclos = 24
ciclos para la secuencia (5),.., (11), (5’),...., (11’). Además, habrá que añadir cuatro
ciclos correspondientes al ciclo de captación de la instrucción de resta (para el control
del final del bucle), y a los tres ciclos asociados a la instrucción de salto. En el esquema
de etapas y ciclos presentado, estos cuatro ciclos son los 17, 18, 19 y 20.
Así pues, cada iteración necesita 28 ciclos (en lugar de los 16 del bucle sin desenrollar),
pero hay que ejecutar la mitad de iteraciones (N/2). Por lo tanto, si a eso se unen los
cuatro ciclos de las instrucciones iniciales, y los tres que hay que esperar para que
termine la ejecución de la última instrucción, el tiempo necesario (suponiendo N par) es:
Tdesenrollado1(N) = 7 + 28*(N/2) = 7 + 14*N
De esta forma, el número de ciclos que se reduce es igual al doble del número de
iteraciones del bucle inicial. Mediante una simulación del código anterior con WinDLX
se puede comprobar que el número de ciclos obtenido es 903 (N=64 en el programa).
Se puede reducir algo más el tiempo de ejecución si se reordenan las instrucciones en el

código correspondiente al bucle desenrollado (aprovechando que en cada iteración se
tienen más instrucciones para reordenar). Una posible forma de reordenar las
instrucciones se muestra a continuación.
start: ld f0,a (1)

add r8,r0,rx (2)
addi r4,r8,#512 (3)
add r12,r0,ry (4)
loop: ld f2,0(r8) (5)
ld f4,0(r12) (7)
multd f2,f0,f2 (6)
ld f6,8(r8) (5’)
ld f8,8(r12) (7’)
addd f4,f2,f4 (8)
multd f6,f0,f6 (6’)
sd 0(r12),f4 (9)
addi r8,r8,#16 (10’)
sub r20,r4,r8 (12)
addd f8,f6,f8 (8’)
sd 8(r12),f8 (9’)
addi r12,r12,#16 (11’)
bnez r20,loop (13)
Los cambios realizados con respecto al primer bucle desenrollado buscan distanciar en
el código aquellas instrucciones entre las que existían riesgos ocasionaban pérdidas de
ciclos. Así, para evitar el riesgo RAW entre las instrucciones (5) y (6), se ha introducido
entre ellas la instrucción (7). Entre las instrucciones (6) y (8) se han introducido dos
instrucciones sin dependencias entre ellas ni con (6) u (8) por lo que se reduce en uno, el
número de ciclos que se pierden en la situación anterior, ya que entre (6) y (8) hay dos
instrucciones en lugar de una. Igualmente, entre (6’) y (8’) se han introducido tres
instrucciones, y se reducen en dos, el número de ciclos que se perdían por las
dependencias entre la multiplicación y la suma. Sin embargo, al quedar las instrucciones
(9’) y (11’), una al lado de otra, se produce una pérdida de un ciclo por la dependencia
en r12.
Así pues, en cada iteración se pierden cuatro ciclos debido a dependencias, con respecto
al caso ideal en el que cada instrucción tarda un ciclo. Así pues, como en la iteración
hay 14 instrucciones y se pierden 4 ciclos, el tiempo de cada iteración es 14+4=18, más
un ciclo que se pierde siempre después de la instrucción de salto. En total tenemos que
cada iteración necesita 19 ciclos, y por tanto (teniendo en cuenta que N es par):
Tdesenrollado2(N) = 7 + 19*(N/2) = 7 + 9.5*N
De esta forma, se ganan 4.5 ciclos por iteración con respecto al desenrollado anterior, y
6.5 ciclos por iteración con respecto a la situación inicial.
Estos datos se pueden comprobar mediante una simulación con WinDLX de los
programas propuestos.
Utilice la técnica de segmentación software (software pipelining) para mejorar las
prestaciones del programa que realiza el cálculo de aX+Y (sin utilizar desenrollado de
bucle). Siga considerando que el tiempo de la multiplicación es de 5 ciclos, y el de la
suma de 2 ciclos.
Solución.
El siguiente código muestra una forma posible de aplicar segmentación software al
programa que se utiliza de partida en el problema 4.
start: ld f0,a (1)
add r8,r0,rx (2)
addi r4,r8,#512 (3)
add r12,r0,ry (4)
loop0: ld f2,0(r8) (5)
multd f2,f0,f2 (6)
ld f4,0(r12) (7)
ld f6,8(r8) (8)
ld f8,8(r12) (9)
addd f4,f2,f4 (10)
loop: sd 0(r12),f4 (11)
multd f6,f0,f6 (12)
addi r8,r8,#8 (13)
addi r12,r12,#8 (14)
addd f4,f6,f8 (15)
ld f6,8(r8) (16)
ld f8,8(r12) (17)
sub r20,r4,r8 (18)
bnez r20,loop (19)
nop (20)
trap #0 (21)
En el programa, las instrucciones (1) – (4) coinciden con las del programa inicial, y
permiten que r8 apunte al comienzo del vector X, r12 al comienzo del vector Y, r4
apunta al primer byte después del vector X, y f0 se carga con el dato a.
Después, la instrucción (5) carga f2 con la primera componente de X, y se multiplica

por a en la instrucción (6). La instrucción (7) carga la primera componente de Y en f4, y
las instrucciones (8) y (9) cargan las segundas componentes de X e Y en f6 y f8,
respectivamente.
La instrucción (10) realiza la suma de la primera componente de aX y la primera de Y.

Como se puede ver, se han introducido las instrucciones (8), y (9) entre esta instrucción
y la instrucción (7) donde se carga la primera componente de Y, para retrasar la
ejecución de (10) con respecto a (6) y a (7), y reducir el efecto de los riesgos RAW.
En este grupo de instrucciones (5)-(10) que van desde la posición loop0 hasta la loop se
hacen los loads de la primera iteración, los cálculos de la primera iteración y los loads
de la segunda iteración.
Dentro del bucle:
- En la primera iteración la instrucción (11) realiza el almacenamiento del

resultado de la primera componente. Así, en la iteración i, se almacenará el
resultado de correspondiente a la componente i.
- En la primera iteración, las instrucciones (12) y (15) realizan los cálculos con los
datos correspondientes a la segunda componente, a los que se ha accedido
mediante las instrucciones (8) y (9). Por lo tanto, en la iteración i del bucle, se
realizan las operaciones con las componentes i+1.
- En la primera iteración, las instrucciones (16) y (17) captan los datos
correspondientes a las terceras componentes de los vectores X e Y. Es decir, que
en la iteración i, se cargan las componentes i+2. Para ello, en (16) y (17) se
accede a la posición r8+8 y a la r12+8 respectivamente, puesto que en las
instrucciones (13) y (14) ya se había incrementado r8 y r12 en 8.
- En la última iteración, (11) almacena la última componente del resultado; (12) y

(15) hacen un cálculo innecesario con datos que se captaron en la iteración
anterior por (16) y (17); y (16) y (17) captan datos innecesarios. Dado que el
efecto de (12) y (15) en la última iteración, y los de (16) y (17) en la última y en
la penúltima no afectan al resultado del programa, no hace falta deshacer su
efecto o evitar que se ejecuten.
- En el bucle, se han reordenado las instrucciones para evitar el efecto de los

riesgos RAW. Así, (12) y (15) están lo más separadas posible, y lo mismo pasa
con (13) y (16), y con (14) y (17).
El tiempo de ejecución del programa en este caso se puede estimar si se tienen en cuenta
las instrucciones entre las que hay dependencias de tipo RAW y su separación. Así:
- Entre la instrucción (5) y (6) hay un RAW que dará lugar a un ciclo perdido por
que cuando empieza la multiplicación todavía no se ha terminado el acceso a
memoria: 1 ciclo perdido
- Entre la (6) y la (10) también hay un RAW, y puesto que la multiplicación que se
realiza en la (6) tarda (5) ciclos, se perderá un ciclo, ya que se introducen 3
instrucciones entre la (6) y la (10): 1 ciclo perdido
- Entre la (1) y la (11) hay un RAW, y puesto que la suma tarda dos ciclos, se
perderá un ciclo (suponiendo que hay adelantamiento, o caminos de bypass para
llevar el resultado de la suma directamente al registro para el almacenamiento en
memoria): 1 ciclo perdido
- Entre la (12) y la (15) hay un RAW, igual que entre la (5) y la (6). No obstante,
como ahora sólo se introducen dos instrucciones entre ellas, se perderán dos
ciclos: 2 ciclos perdidos
- Al terminar (15) se pierde un ciclo, debido ya que la suma tarda dos ciclos y
habrá un riesgo estructural con alguna de las instrucciones que la siguen para
acceder a la etapa MEM: 1 ciclo perdido.
- Entre la (18) y la (19) se pierde otro ciclo debido al riesgo RAW que existe entre
estas instrucciones, y a que se necesita haber ejecutado (terminado la etapa EX)
la instrucción (18) antes de que (19) esté en su etapa de decodificación (ID): 1
ciclo perdido.
Teniendo en cuenta el efecto de los riesgos en los ciclos perdidos tenemos que el tiempo
del programa anterior se puede calcular como sigue:
(1) Tiempo de la instrucciones (1) – (10) y primera iteración del bucle (11)-(19):
4 (primeras cuatro etapas de la primera instrucción) +

19 (número de instrucciones) +
7 (ciclos perdidos) –
3 (la primera instrucción de la segunda iteración empieza justo después de la
etapa ID de la instrucción de salto (19)) = 27 ciclos
(2) Restantes 63 iteraciones de (11) – (19)
4 (primeras cuatro etapas de la primera instrucción del bucle) +

9 (número de instruciones) +
4 (ciclos perdidos por las dependencias entre instrucciones dentro del bucle) –
3 (la primera instrucción de la segunda iteración empieza justo después de la
etapa ID de la instrucción de salto (19)) = 14 ciclos x 63 (iteraciones) = 882
(3) Ciclos hasta que termina la última instrucción: 3 (o 4 si se cuenta la instrucción

nop).
Sumando (1), (2), y (3) se tiene un total del 912 ciclos, que supone una reducción de
1031 – 912 = 119 ciclos (11.5% de reducción) con respecto a la situación inicial del
problema 4.
En función de N, se tendría T(N) = 16 + 14 N. Es decir, que la reducción de tiempo

sería aproximadamente igual a 2N, con respecto a la situación inicial (para valores de N
suficientemente grandes). Como se ve, se tiene una complejidad similar a la que se
obtenía con el desenrollado.
En cualquier caso, es posible obtener mejores prestaciones todavía si se reorganizan

algo más las instrucciones para evitar la pérdida de algunos ciclos por los riesgos
existentes. Por ejemplo, en el programa que se muestra a continuación:
start: ld f0,a (1)

add r8,r0,rx (2)
ld f2,0(r8) (5)
addi r4,r8,#512 (3)
multd f2,f0,f2 (6)
add r12,r0,ry (4)
ld f4,0(r12) (7)
ld f6,8(r8) (8)
ld f8,8(r12) (9)
addd f4,f2,f4 (10)
loop: multd f6,f0,f6 (12)
sd 0(r12),f4 (11)
addi r8,r8,#8 (13)
addi r12,r12,#8 (14)
addd f4,f6,f8 (15)
sub r20,r4,r8 (18)
ld f6,8(r8) (16)
ld f8,8(r12) (17)
bnez r20,loop (19)
nop (20)
trap #0 (21)
Después de la reordenación realizada, sólo se pierden dos ciclos por iteración: uno
debido a dependencia RAW entre (12) y (15), entre las que se han introducido 3
instrucciones, y otro ciclo debido a un riesgo estructural al terminar (15) puesto que las
instrucciones que la siguen sólo necesitan un ciclo en la fase EX.
Según esto, el tiempo de ejecución es:
T(64) = 22 (primera ejecución de (1) – (19)) +

12 * 63 (63 iteraciones restantes) + 3 (hasta terminar) = 781
que supone casi un 25% menos de tiempo que en la situación inicial del problema 4.
Para N, se tendrá T(N) = 13 + 12* N, con lo que se consigue una reducción de 4*N
(para N elevados) con respecto a la situación inicial del problema 4.
(Nota: Los tiempos obtenidos se pueden comprobar mediante simulación de los

programas con WinDLX).
En el problema 4 se ha supuesto que el procesador abortaba cualquier instrucción que se
captase después de una instrucción de salto. Esta situación obliga a que se tenga que
introducir una instrucción sin utilidad para el programa (instrucciones de no-operar).
Indique qué cambio haría en el código inicial si el procesador captara y ejecutara
normalmente la instrucción que sigue a una instrucción de salto condicional.
Solución.
Una forma posible de aprovechar que las instrucciones que siguen a una instrucción de
salto se ejecutan normalmente es poner la primera instrucción de una iteración (la
instrucción (5)) después de la instrucción de salto. Por supuesto, en el caso de que no se
produzca el salto también se ejecutará, y habrá que estudiar si esto tiene efectos en la
semántica del programa.
En el ejemplo que se muestra a continuación, la instrucción de carga de f2 con r8 se

ejecutaría innecesariamente al final del programa, modificando f2. Habría que ver si
esto afecta al resto de la aplicación.
start: ld f0,a (1)

add r8,r0,RX (2)
addi r4,r8,#512 (3)
add r12,r0,RY (4)
ld f2,0(r8) (5)
loop: multd f2,f0,f2 (6)
ld f4,0(r12) (7)
addd f4,f2,f4 (8)
sd 0(r12),f4 (9)
addi r8,r8,#8 (10)
addi r12,r12,#8 (11)
sub r20,r4,r8 (12)
bnez r20,loop (13)
ld f2,0(r8) (5)
Otra posible mejora consiste en poner una instrucción de la iteración que siempre tiene
que ejecutarse, pero no afecta a la condición del salto. En el programa anterior se podría
situar detrás de la instrucción de salto, una de las instrucciones que actualizan los
registros que sirven de puntero para ir accediendo a los componentes del vector:
instrucción (11). En ese caso, el código sería:
start: ld f0,a (1)

add r8,r0,RX (2)
addi r4,r8,#512 (3)
add r12,r0,RY (4)
loop: ld f2,0(r8) (5)
multd f2,f0,f2 (6)
ld f4,0(r12) (7)
addd f4,f2,f4 (8)
sd 0(r12),f4 (9)
addi r8,r8,#8 (10)
sub r20,r4,r8 (12)
bnez r20,loop (13)
addi r12,r12,#8 (11)
En cualquier caso, hay que asegurarse que, al cambiar de sitio una instrucción, no se
empeora el efecto de posibles dependencias que no afectaban porque la instrucción
retardaba la captación de una instrucción con respecto a otras. En el código anterior, la
instrucción (11) retardaba la ejecución de (12) respecto de (10). No obstante, si se
considera que hay caminos de bypass, esta dependencia de tipos RAW entre (10) y (12)
no tiene efecto.
7 (Benchmark diciembre 2007)

Considere el procesador segmentado que simula WINDLX y considere que implementa
un salto retardado en el que la instrucción situada a continuación de la instrucción de
salto condicional no se anula nunca. Escriba el programa DLX que permite ejecutar:
for (i=0 ; i<n ; i++)

D(i)=A[i]+B[i]+C[i];
Realice las transformaciones necesarias para obtener un código eficiente en el que se

aproveche la instrucción ubicada tras la instrucción de salto condicional. ¿Cómo sería el
código si el procesador implementara la opción de anular si no se salta? ¿Y si la opción
es anular siempre?
Notas:
 Considere que los elementos de las matrices A, B, C y D están situados en
posiciones consecutivas a partir de las direcciones almacenadas en R1, R2, R3 y R4
respectivamente y que el valor de N está almacenado en R5.
 Los elementos de las matrices son números reales de 32 bits.
Solución.
Para el caso en que el procesador no anule nunca la instrucción situada a continuación
del salto, el código del programa sería el siguiente:
(1) inicio: lw r11, 0(r1) ; r11 = a[i]

(2) lw r12, 0(r2) ; r12 = b[i]
(3) lw r13, 0(r3) ; r13 = c[i]
(4) add r14, r11, r12 ; r14 = a[i] + b[i]
(5) add r14, r13, r14 ; r14 = r14 + c[i]
(6) sw 0(r4), r14 ; d[i] = r14
(7) subi r5, r5, #1 ; n = n - 1
(8) addi r1, r1, #4 ; r1 apunta a a[i+1]
(9) addi r2, r2, #4 ; r2 apunta a b[i+1]
(10) addi r3, r3, #4 ; r3 apunta a c[i+1]
(11) bnez r5, inicio ; saltamos si n != 0
(12) addi r4, r4, #4 ; r4 apunta a d[i+1]
Como el código utiliza la ALU para hacer todas las operaciones aritméticas, la latencia
de todas las operaciones es de un ciclo, con lo que suponiendo que existen caminos de
bypass, no existirían atascos en el cauce. Para aprovechar el salto retardado se ha
retrasado la instrucción que incrementa r4, que se ejecutará tanto si se salta como si no.
Para el caso de que el procesador anule la instrucción a continuación del salto si no se
salta (se supone que siempre se va a saltar), el código anterior funcionaría sin
problemas, ya que sólo se anularía el incremento de r4 en la última iteración, cuando
ya no hace falta volver a usarlo. Por último, si el procesador anulara siempre la
instrucción que está situada a continuación del salto, habría que subir el incremento de
r4 antes del salto y colocar tras el salto una instrucción nop, para que su anulación no
nos cause ningún problema.
8 (Examen febrero 2007)

Considere un procesador con arquitectura DLX que implementa un cauce segmentado
en cinco etapas (IF, ID, EX, MEM, WB). Para los números en coma flotante se añaden
además un sumador con una latencia de 2 ciclos y un multiplicador con una latencia de
3 ciclos. Existen caminos de bypass desde la salida de las unidades de ejecución y desde
la etapa de memoria a las entradas de la ALU. Las instrucciones de salto se procesan en
la etapa de decodificación, por lo que la nueva dirección a la que se ha de acceder si se
produce el salto estará disponible al final de dicha etapa. Se implementa salto retardado
en el que no se anula nunca la siguiente instrucción que se haya podido introducir en el
cauce tras un salto (el salto se resuelve en la etapa de decodificación). Considerando el
código siguiente:
add r1, r0, r0 ; Inicializamos el índice i a 0

subd f0, f0, f0 ; Inicializamos el acumulador a 0
bucle: ld f2, X(r1) ; Cargamos X(i)
multd f6, f2, f4 ; Multiplicamos X(i) por a (en f4)
addd f0, f0, f6 ; Acumulamos el resultado
addi r1, r1, #8 ; Incrementamos el contador del índice
subi r3, r3, #8 ; Comprobamos si hemos acabado
bnez r3, bucle ; Saltamos si quedan elementos
sd R, f0 ; Guardamos el resultado
(a) ¿Se ejecutaría el programa correctamente tal y como está? ¿Qué cambios haría
para aprovechar el salto retardado?
(b) ¿Cuál es la productividad del cauce en función del número de iteraciones N?
Solución.
El programa se ejecuta correctamente, ya que en cada iteración se ejecutará la
instrucción de almacenamiento que hay detrás del salto y el efecto que tendrá será
simplemente el de almacenar la suma parcial acumulada en f0. Sin embargo, esta
operación, aunque no provoca que el resultado sea incorrecto, sí que repercute en el
tiempo de ejecución del programa, ya que si el vector X tiene N elementos, se realizarán
N – 1 almacenamientos que consumen un tiempo de ejecución que podría usarse para
algo más provechoso. Por ejemplo, una posible optimización podría ser la siguiente:
add r1, r0, r0 ; Inicializamos el índice i a 0

subd f0, f0, f0 ; Inicializamos el acumulador a 0
bucle: ld f2, X(r1) ; Cargamos X(i)
subi r3, r3, #8 ; Comprobamos si hemos acabado
multd f6, f2, f4 ; Multiplicamos X(i) por a (en f4)
addd f0, f0, f6 ; Acumulamos el resultado
bnez r3, bucle ; Saltamos si quedan elementos
addi r1, r1, #8 ; Incrementamos el contador del índice
sd R, f0 ; Guardamos el resultado
En este caso, la instrucción de después del salto retardado se utiliza para incrementar el
puntero al siguiente elemento de X, instrucción que hay que realizar de todas formas,
con lo que el cuerpo del bucle pasa a tener una instrucción menos que antes. Además, la
instrucción de resta se ha colocado detrás la instrucción de carga para ocultar su retardo
carga-uso.
Para obtener la productividad del cauce primero tenemos que calcular cuánto tiempo
tarda en ejecutarse el programa para un vector de N elementos:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
add r1, r0, r0 ME W

IF ID EX
M B
subd f0, f0, f0 ME W
IF ID EX EX
M B
ME W
ld f2, X(r1) IF ID EX X
M B
ME W
subi r3, r3, #8 IF ID X EX
M B
ME W
multd f6, f2, f4 IF X ID EX EX EX
M B
ME W
addd f0, f0, f6 IF ID X X EX EX
M B
bnez r3, bucle IF X X ID
ME W
addi r1, r1, #8 IF ID X EX
M B
ME
sd R, f0 IF X ID EX WB
M
Las partes sin sombrear de la figura indican el tiempo de inicialización y finalización

del programa, mientras que la parte que está sombreada es el tiempo que transcurre
entre dos iteraciones del bucle, es decir, que tardamos 2 ciclos en comenzar la primera
iteración, que transcurren 9 ciclos entre el comienzo de una iteración y el comienzo de
la siguiente, y que tras la última iteración se tardan 6 ciclos en acabar. Por tanto, el
tiempo que tardaría en ejecutarse el programa para procesar un vector de N elementos
sería:
TN  2  9 N  6  9 N  8
Sabiendo el tiempo de ejecución, la productividad del cauce se puede expresar en
términos de resultados por ciclo o de instrucciones por ciclo:
Nº instrucciones 6 N  3 Nº resultados N
WN   instr./cic loWN   resultados/ciclo
Tiempo 9N  8 Tiempo 9N  8
9 (Examen septiembre 2007)

Suponga que en el siguiente programa N=108, a y c son dos vectores de números en
coma flotante, y b es un escalar en coma flotante.
for (i=0 ; i<N ; i++)

a[i+2] = (a[i+1] + a[i]) * b;
c[0] = a[N+1];
Si el programa anterior se implementa en un procesador segmentado con salto retardado

y un hueco para instrucciones tras la instrucción de salto, indique si hay algún problema
en la ejecución del código anterior si el salto: (1) se anula siempre; (2) no se anula
nunca; (3) se anula si se salta; (4) se anula si no se salta.
¿Qué cambios haría en el código en el caso en que hay problemas y para que, si es
posible, se mejoren las prestaciones?
Solución.
Las instrucciones máquina que implementan este bucle en el procesador donde se ha

ejecutado son:
ld f1, b ; cargar en f1 el valor de b

add r1, r0, a ; apuntar r1 donde empieza a[]
ld r2, N ; cargar en r2 el número de iteraciones
loop: ld f2, 0(r1) ; cargar f2 con a[i]
ld f3, 4(r1) ; cargar f3 con a[i+1]
addf f4, f3, f2 ; f4=a[i+1]+a[i]
mulf f4, f4, f1 ; f4=f4*b
sf 8(r1), f4 ; almacenar f4 en a[i+2]
add r1, r1, #4 ; apuntar a a[i+1]
sub r2, r2, #1 ; queda una iteración menos
bnez r2, loop
add r5, r0, c ; apuntar r5 donde empieza c[]
sf 0(r5), f4 ; almacenar f4 (a[N+1]) en c[0]
Dependiendo de la implementación del salto retardado, puede que sea necesario cambiar
el código del programa para asegurar su correcto funcionamiento:
(1) En el caso en el que la instrucción que entra en el cauce tras el salto se anule
siempre, sería necesario insertar una instrucción NOP entre el salto y la suma, ya
que en la última iteración, en la que no se debe saltar, se anularía la siguiente
instrucción al salto y la operación de almacenamiento final no accedería a la
dirección correcta.
(2) Si la instrucción siguiente al salto no se anula nunca, el programa podría fallar si

dicha instrucción afecta a los registros que se usan en el bucle. En este ejemplo
concreto, como dicha instrucción afecta a r5, que no se usa en el bucle, el
programa funcionaría correctamente, aunque ejecutaría la instrucción siguiente
al salto en todas las iteraciones, desperdiciando un tiempo de computación que
podría usarse en algún cálculo útil.
(3) Si la siguiente instrucción al salto se anula sólo si se toma el salto, el programa

se puede dejar tal y como está, ya que sólo se ejecutará cuando se termine el
bucle.
(4) Por último, si la siguiente instrucción al salto se anula sólo si no se salta, ocurre
igual que en el caso (2), el programa podría fallar si dicha instrucción afecta a
los registros que se usan en el bucle. Pero en este ejemplo concreto el programa
funcionaría correctamente si el bucle itera más de una vez, ya que se fijaría en r5
el valor del puntero donde empieza la matriz c en todas las iteraciones menos en
la última, por lo que en el almacenamiento se accedería a la dirección correcta.
En este caso, también sería conveniente modificar el programa para ejecutar la
instrucción siguiente al salta una sola vez tras la última iteración y aprovechar el
spot del salto para realizar algún cálculo útil.
A continuación se muestran las modificaciones que serían necesarias para optimizar el

programa en cada caso:
Se anula siempre No se anula nunca Se anula si se salta Se anula si no se salta

ld f1, b ld f1, b ld f1, b ld f1, b
add r1, r0, a add r1, r0, a add r1, r0, a add r1, r0, a
ld r2, N ld r2, N ld r2, N ld r2, N
loop: ld f2, 0(r1) loop: ld f2, 0(r1) loop: ld f2, 0(r1) ld f2, 0(r1)
ld f3, 4(r1) ld f3, 4(r1) ld f3, 4(r1) loop: ld f3, 4(r1)
addf f4, f3, f2 addf f4, f3, f2 addf f4, f3, f2 addf f4, f3, f2
mulf f4, f4, f1 mulf f4, f4, f1 mulf f4, f4, f1 mulf f4, f4, f1
sf 8(r1), f4 sf 8(r1), f4 sf 8(r1), f4 sf 8(r1), f4
add r1, r1, #4 sub r2, r2, #1 add r1, r1, #4 add r1, r1, #4
sub r2, r2, #1 bnez r2, loop sub r2, r2, #1 sub r2, r2, #1
bnez r2, loop add r1, r1, bnez r2, loop bnez r2, loop
nop #4 add r5, r0, c ld f2, 0(r1)
add r5, r0, c add r5, r0, c sf 0(r5), f4 add r5, r0, c
sf 0(r5), f4 sf 0(r5), f4 sf 0(r5), f4
Cualquiera de las soluciones (2) y (4) son intercambiables para ambos casos.
Optimización
Suponga que las etapas de una unidad funcional segmentada S1, S2, S3, S4, y S5 se
utilizan en el orden S1,S3,S5,S1,S3,S4,S1,S3,S2,S5,S4,S2. ¿Cuál es el tiempo (en
número de ciclos) de latencia de inicio del cauce? ¿Cuál es la tabla de reservas y el
vector de colisiones inicial?. Si se supone el cauce vacío inicialmente y se introduce una
operación, ¿es posible introducir otra pasados 5 ciclos? ¿Cuál es el número mínimo de
ciclos que hay que esperar? ¿Cuáles son las latencias prohibidas en ese caso una vez que
se ha introducido la segunda operación?
Solución.
El tiempo de latencia de inicio del cauce es el tiempo que el cauce tarda en terminar una
operación (el tiempo que tarda en pasar por las distintas etapas hasta que se completa la
operación). Es igual, por tanto, al tiempo que tarda en terminarse la primera operación,
desde el momento en que empezó a funcionar.
En este caso, el tiempo de latencia de inicio es igual a 12 ciclos, ya que este es el

número de etapas por el que tiene que pasar cada operación.
La tabla de reservas tendrá, por tanto 12 columnas y 5 filas (una por etapa física del
cauce).
0 1 2 3 4 5 6 7 8 9 10 11
S1
X X X
S2
X X
S3
X X X
S4
X X
S5
X X
La lista de latencias prohibidas se obtiene contando, línea por línea, las columnas que
hay entre cada cruz y cada una de las que le siguen en esa misma línea. Por ejemplo, si
se toma la línea correspondiente a S1, las latencias prohibidas que hay son 3 (debido a
la cruz en 3 con respecto a la cruz en 0, y debido a la cruz en 6 con respecto a la cruz en
3) y 6 (debido a la cruz en 6 con repecto a la cruz en 0).
Así, la lista de latencias prohibidas es F = {3, 5, 6, 7}
y el vector de colisiones inicial tendrá 7 componentes, teniendo unos en las

componentes 3, 5, 6, y 7 ya que esas son las latencia prohibidas
C = (1110100)
Eso quiere decir que, si tenemos el cauce vacío y se inicia una operación, las latencias
prohibidas para las operaciones que se intenten iniciar a continuación son 3, 5, 6, y 7, y
por tanto, cinco ciclos después de iniciar una operación (estando el cauce vacío) no
se puede iniciar otra operación.
El número mínimo de ciclos que hay que esperar una vez introducida una
operación (con el cauce vacío) es 1, ya que la componente 1 del vector de colisiones
inicial es 0 (es decir, 1 no es latencia prohibida).
Si se espera un ciclo, y se inicia otra operación (después de la que se introdujo primero),

el vector de colisiones es igual a la suma del vector de colisiones iniciales (porque este
representa las latencias prohibidas que aparece debido a que se introduce una nueva
operación en el cauce) más (es decir, la unión bit a bit de los vectores) el vector de
latencias prohibidas que ya había, desplazado una posición (ya que se ha introducido la
operación nueva después de un ciclo) hacia la derecha.
(1110100) Vector de colisiones inicial (las que origina la nueva operación)
(0111010) Vector de colisiones que había, desplazado una posición a la derecha (ha
pasado un ciclo)
________ (Unión bit a bit)
(1111110) Por lo tanto, hay latencias prohibidas en los ciclos 2, 3, 4, 5, 6, 7 (se

puede introducir una nueva operación en el ciclo siguiente, o esperando 8
ciclos.

La operación de multiplicación de números en punto flotante en un determinado
procesador tiene una latencia de 25 ns. Tras aplicar una serie de benchmarks se ha
observado que esta operación se utiliza en un número muy significativo ocasiones, con
lo que el equipo de arquitectos se ha planteado desarrollar una implementación
multiplicación segmentada en 4 etapas que siga la siguiente secuencia de operación: S1
S2 S3 S1 S2 S4 S4 S3.
Si la latencia de las etapas S1, S2, S3 y S4 es de 6 ns, 5 ns, 4 ns y 5 ns respectivamente y

los registros de acoplo entre etapas necesitan 1 ns para cargarse, ¿cuál es la ganancia y
la productividad máxima que se puede obtener con esta nueva implementación?
Solución.
La ganancia en velocidad y la productividad del nuevo diseño se obtienen mediante las
siguientes ecuaciones:
Tno segmentado ( n)
S ( n)  (1)
Tsegmentado ( n)
n
W (n)  (2)
Tsegmentado ( n)
El tiempo no segmentado para n operaciones es muy sencillo de obtener, ya que en el

enunciado se nos dice que cada operación tarda 25 ns, con lo que:
Tno segmentado (n)  25  n (3)
El tiempo segmentado se obtiene mediante la siguiente expresión:
Tsegmentado (n)  TLI  MLM   n  1 (4)

El tiempo segmentado está compuesto por la latencia inicial, que es el tiempo que tarda
en salir la primera operación, más el tiempo que tardan el resto de operaciones por la
mínima latencia mínima que debe esperarse para no causar colisiones en el cauce. Dado
que el cauce está formado por 8 etapas lógicas y que en cada una se debe tardar un ciclo
de reloj, el tiempo de latencia inicial es:
TLI  numEtapas  t reloj  8  t reloj (5)
Así que para completar el cálculo de TLI necesitamos saber cuántos nanosegundos dura
cada ciclo de reloj. Teniendo en cuenta la duración de cada una de las etapas físicas y el
tiempo de los registros de acoplo, el tiempo de reloj se obtiene como:
t reloj  max tiempos de las etapas  t acoplo  max{6,5,4,5}  1  6  1  7 ns

(6)
Por lo que a partir de las ecuaciones (5) y (6) podemos concluir que el tiempo de
latencia inicial es de:
TLI  8  t reloj  8  7 ns  56 ns (7)
Para el cálculo de la mínima latencia media es necesario partir de la tabla de reservas:
1 2 3 4 5 6 7 8
S1 X X
S2 X X
S3 X X
S4 X X
De esta tabla obtenemos que el conjunto de latencias prohibidas del cauce es:
F  1,3,5 (8)
Por lo que el vector de colisiones es el siguiente:
C  10101 (9)
A partir de este vector se puede generar el diagrama de estados posibles del cauce,
obteniéndose:
10101 2, 4, 6+
Con lo que es fácil ver que la mínima latencia del cauce son 2 ciclos, así que:
MLM  2  t reloj  2  7 ns  14 ns (10)
De las ecuaciones (4), (7) y (10) podemos deducir que el tiempo segmentado es de:
Tsegmentado ( n)  TLI  MLM   n  1  56  14   n  1 ns (11)
Así que ya podemos calcular las expresiones de ganancia y productividad del cauce
segmentado a partir de las ecuaciones (1), (2), (3) y (11):
Tno segmentado (n) 25  n

S ( n)   ns (12)
Tsegmentado ( n) 56  14   n  1
n n
W (n)   ns 1 (13)

Tsegmentado ( n) 56  14  n  1 
Las expresiones máximas se obtienen tomando límites cuando n → ∞:
25  n 25
S max  lim S (n)  lim   1.79 ns (14)
n 56  14   n  1 14
n
n 1
Wmax  lim W ( n)  lim   0.07143 ns 1  71.43  s 1
n  n  56  14   n  1 14
(15)

Una función F se ejecuta en un cauce con 4 etapas S1,S2,S3,S4, según la secuencia:
S1S3S4S1S3S2S2S4¿Cuál es la ganancia de velocidad con respecto a su ejecución sin
cauce, para 200 operaciones, teniendo en cuenta que sin cauce la función requiere un
tiempo de 16 ns; que las etapas del cauce suponen unos tiempos de ejecución de: 4ns
para S1, 5ns para S2, 3 ns S3 y 4 ns para S4; y que los registros introducen retardos de
0.5ns?. ¿Cuál es la productividad máxima del cauce?

Una función F se va a implementar en un cauce con 5 etapas S1, S2, S3, S4, S5 de forma
que visita las etapas según la secuencia: S1 S5 S1 S4 S3 S2 S1 S4. Obtenga la ganancia
en velocidad con respecto a la ejecución sin cauce para 200 operaciones, teniendo en
cuenta que sin cauce la función requiere un tiempo de 16 ns y que las etapas del cauce
suponen unos tiempos de ejecución de 4 ns para S1, S4 y S5, 5 ns para S2, y 3 ns para
S3 (incluyendo los retardos de los registros de acoplo). ¿Cuál es la productividad en
función del número de operaciones? Determine los valores de la productividad máxima
y la ganancia máxima.
Solución.
La ganancia en velocidad S(n) se define como el cociente entre los tiempos sin
segmentar y segmentado para ejecutar n operaciones:
TOrig (n) TOrig ( n)

S Seg (n)  
TSeg ( n) TLI  (n  1) MLM
Viendo el tiempo de ejecución de las diferentes etapas, fijaremos el tiempo de reloj del
cauce a:
TReloj  max 3 ns, 4 ns, 5 ns  5 ns
Por lo que el tiempo de latencia inicial es:
TLI  8 etapas  TReloj  8  5 ns  40 ns
Una vez obtenido el TLI, sólo nos queda obtener la Mínima Latencia Media (MLM) del
cauce propuesto en el enunciado. La tabla de reservas del cauce es la siguiente:
1 2 3 4 5 6 7 8
S X X X
1
S X
2
S X
3
S X X
4
S X
5
Mediante esta tabla de reservas, es fácil obtener las latencias prohibidas y los vectores
de colisiones:
F = {2,4,6} C = (101010)
Por último, para determinar la MLM, realizamos un diagrama de estados a partir del
vector de colisiones:
7+
7+
7+ 101010
1
3 1
7+ 5
5
101111 101011 111111
5
3
La mínima latencia mínima del cauce es:
MLM = (5 + 3) / 2 = 4 ciclos = 4 · 5 ns = 20 ns
Por tanto, el tiempo tardará la ejecución de n operaciones en el cauce segmentado será
TSeg ( n)  TLI  (n  1)  MLM  40  ( n  1)  20  20  (n  1)

Utilizando esta expresión, ya podemos calcular la ganancia en velocidad para 200
operaciones mediante:
TOrig (200) 200  16 3200

S Seg (200)     0.796
TSeg (200) 20  (200  1) 3980
La productividad en función del número de operaciones se define como:
n n
WSeg ( n)  
TSeg ( n) 20  ( n  1)
Los valores para la productividad y la ganancia máximas son:
1 1 16 16
Wmax    50 MOPS S max    0.8
MLM 20 ns MLM 20
14 (Examen diciembre 2007)

Se han encontrado dos posibles alternativas para la ejecución de una función F en un
cauce con 4 etapas S1, S2, S3 y S4. La alternativa 1 visita las etapas según la secuencia
S1 S2 S1 S3 S2 S3 S4, y la alternativa 2 en el orden S1 S2 S3 S4 S2 S4. (A) ¿Cuál de las
dos alternativas permite ejecutar un número mayor de funciones por unidad de tiempo?
Demuestre razonadamente su respuesta. (B) Obtenga además la ganancia en velocidad
que ofrece cada una de las alternativas con respecto a su ejecución sin cauce para 500
operaciones, teniendo en cuenta que sin cauce la función requiere un tiempo de 15 ns;
que las etapas del cauce suponen unos tiempos de ejecución de: 4 ns para S1, 5 ns para
S2, 2 ns para S3 y 4 ns para S4; y que los registros de acoplo entre etapas introducen un
retardo de 0.25 ns.
Solución.
El primer paso para resolver este problema es calcular la tabla de reservas para cada una
de las dos alternativas:
Alternativa 1 Alternativa 2
1 2 3 4 5 6 7 1 2 3 4 5 6
S X X S X
1 1
S X X S X X
2 2
S X X S X
3 3
S X S X X
4 4
Una vez calculadas las tablas de reservas es fácil obtener las latencias prohibidas y los
vectores de colisiones de cada una de las alternativas:
F1 = {2,3} C1 = (110) F2 = {2,3} C2 = (110)

Como las dos alternativas tienen las mismas latencias prohibidas, las dos tendrán la
misma productividad, así que como la segunda alternativa, además tiene una latencia
inicial menor, la mejor alternativa sería la segunda. El cálculo de la mínima latencia
media es igual para ambas alternativas. Primero se dibuja el diagrama de estados:
110 111
4+
Y después se busca el ciclo de menor latencia, que en este caso será el único ciclo del
diagrama. Por tanto, la latencia mínima es:
1 4
MLM   2,5
2
Para responder a la segunda cuestión, debemos calcular tanto el tiempo de ejecución en

el procesador secuencial, como el de cada una de las alternativas segmentadas, para
realizar 500 operaciones. En el caso secuencial tenemos que:
TSec(500) = 500 operaciones × 15 ns/operación = 7500 ns
Para cualquiera de las dos alternativas segmentadas, el tiempo de ejecución se define

como:
T (n)  TLI  (n  1)  MLM   Tclock
El tiempo ciclo del reloj se puede obtener como:
Tclock = máx{TS1, TS2, TS3, TS4} + Tacoplo = máx {4, 5, 2, 4} + 0,25 = 5 + 0,25 = 5,25 ns
Por tanto, la ganancia en velocidad de cada una de las alternativas respecto al caso
secuencial es de:
TSec (500) 7500 T (500) 7500

S1 (500)    1),139
S 2 (500  Sec   1,140
T1 (500)  7   500  1  2,5  5,25 T2 (500)  6   500  1  2,5  5,25
Se puede comprobar cómo el hecho de que la latencia inicial sea diferente en ambos
cauces no influye significativamente en la ganancia en velocidad que proporcionan.
Se pretende utilizar un cauce con cuatro etapas, A, B, C, D, para aumentar el
rendimiento en la ejecución de una unidad funcional F. Las etapas se pueden utilizar
según una de las dos secuencias S1, y S2 siguientes:
S1 : ABACACABD S2 : ADBCCABD
Si la duración de cada etapa (incluyendo el registro de acoplo) es de 50 ns., y la

operación que implementa la unidad funcional F sin pipeline tarda 350 ns. en ejecutarse.
¿Cuál de las dos posibilidades es la mejor?¿Por qué?. ¿Cuáles son los valores máximos
para la productividad, la eficacia, y la ganancia del cauce en cada una de las secuencias
de utilización, S1, y S2?
Solución.
Para determinar cuál es la mejor opción se determinará la mínima latencia media
(MLM) que se puede conseguir en cada uno de los casos. La opción para la que la MLM
sea menor será la mejor. Para determinar la MLM en cada caso, habrá que construir la
tabla de reservas, generar el diagrama de estados posibles, e identificar los distintos
ciclos según los que se puede implementar la unidad de control del cauce, evaluando sus
latencias medias.
Opción S1)
A X X X X
B X X
C X X
D X
La lista de latencias prohibidas es F = {2,4,6}
y el vector de colisiones inicial, por tanto tiene seis componentes y es C = (101010)
El diagrama de estados posibles del cauce se obtiene a partir de un estado inicial en el

que las latencias prohibidas son las indicadas en el vector de colisiones inicial,
correspondientes a la situación en la que estaba el cauce vacío y se introduce la primera
operación:
+7
A
101010
+7 +7
5 1
3 +7
D 5
101011 101111 111111
3 B
5 C
A partir del diagrama de estados, los ciclos posibles se muestran a continuación, junto
con las latencias y las latencias medias:
Ciclo Latencia Latencia Media
(A) 7 7
(AB) 7+1=8 8/2 = 4 (*)
(AC) 7 + 3 = 10 10/2 =5
(ACD) 3+5+7 = 15 15/3 = 5
(CD) 3+5=8 8/2 =4 (*)
(AD) 7 + 5 = 12 12/2 = 6
(ADC) 5+3+7 = 15 15/3 = 5
(D) 5 5
Los ciclos marcados con (*) son los que presentan la mínima latencia media: MLM=4
Opción S2) La tabla de reservas es:
A X X
B X X
C X X
D X X
Para esta Tabla, las latencias prohibidas son F = {1,4,5,6}
el vector de colisiones inicial es, por tanto C = (111001)
y el diagrama de estados
+7
111001 A
2,3 +7
111111
B
Por lo que los ciclos posible y las latencias medias correspondientes son:
Ciclos Latencia Latencia

Media
(A) 7 7
(AB) 2+7 = 9 9/2 =4.5

Por tanto, el la mínima latencia media posible en este caso es MLM =4.5, por lo que la
primera opción es la mejor.
Las expresiones para la productividad, y la ganancia son las siguientes:
W (n) = n / Tpipeline(n) = n / (Latencia_Inicio + (n-1) * 50 * MLM)
S(n) = Tsin_pipeline(n)/Tpipeline(n) = (350 * n)/(Latencia_Inicio + (n-1) * 50 * MLM)
La latencia de inicio (ciclos que tarda en pasar una operación por el cauce) es de 9
ciclos para S1, y de 8 ciclos para S2. El valor de MLM es de 4 para S1 y de 4.5 para S2,
por lo tanto:
S1)
W(n) = n / (9*50 + (n-1)*4* 50) = n / (450 + 200 (n-1)) -> Wmax = 1 / 200 (nsg-1)
S(n) = (350*n) / (450 + 200 (n-1)) --> Smax = 350 / 200 = 1.75
S2)
W(n) = n / (8*50 + (n-1)*4.5* 50) = n / (400 + 225 (n-1)) -> Wmax = 1 / 225 (nsg-1)
S(n) = (350*n) / (400 + 225 (n-1)) --> Smax = 350 / 200 = 1.56
Los valores de la eficacia se obtienen dividiendo los de la ganancia entre 4, puesto que
éste es el número de etapas del cauce.

cauce con 4 etapas S1, S2, S3, S4. La alternativa 1 visita las etapas según la secuencia:
S1 S3 S1 S3 S2 S4 S4, y la alternativa 2 en el orden: S1 S2 S3 S2 S3 S4 S2. (A) ¿Cuál de
las dos alternativas permite ejecutar un número mayor de funciones por unidad de
tiempo? Demuestre razonadamente su respuesta. (B) Obtenga además la ganancia en
velocidad que ofrecen cada una de las alternativas con respecto a su ejecución sin cauce
para 1000 operaciones, teniendo en cuenta que sin cauce la función requiere un tiempo
de 15 ns; que las etapas del cauce suponen unos tiempos de ejecución de: 4ns para S1,
4 ns para S2, 3 ns S3 y 4 ns para S4; y que los registros introducen retardos de 0.1 ns.
Solución.
El primer paso para responder al primer apartado es calcular la tabla de reservas para
cada una de las dos alternativas:
1 2 3 4 5 6 7 1 2 3 4 5 6 7
S X X S X
1 1
S X S X X X
2 2
S X X S X X
3 3
S X X S X
4 4
F1 = {1,2} C1 = (11) F2 = {2,3,5} C2 = (10110)
Para calcular determinar qué alternativa tiene la máxima productividad, realizamos un

diagrama de estados a partir de cada vector de colisiones:
3
11 1 10110 4
3 6 6
11111 10111
4
La mínima latencia mínima de cada alternativa es:
1 6
MLM1 = 3 MLM 2   3,5
2
Para ver qué alternativa es capaz de ejecutar más operaciones por unidad de tiempo
basta con calcular la productividad máxima de cada una de ellas. La productividad
máxima se define como:
n n 1
Wmax  lim W ( n )  lim  lim 
n n T ( n ) n  TLI  MLM ( n  1) MLM
Para cada una de las alternativas tenemos que:
1 1 1 1
W1 max    0,3 W2 max    0,29
MLM 1 3 MLM 2 3,5
con lo que podemos concluir que la primera alternativa es mejor que la segunda.
Para responder a la segunda cuestión, debemos calcular tanto el tiempo secuencial como
el de cada una de las alternativas para realizar 1000 operaciones. En el caso secuencial
tenemos que:
TSec(1000) = 1000 operaciones · 15 ns/operación = 15000 ns
Y en el caso paralelo, el tiempo de ejecución se define como:
T ( n )  Tclock · TLI  MLM ( n  1) 
secuencial es de:
TSec (1000) 15000 T (1000) 15000

S1 (1000)   S1(1000
1,22 )  Sec   1,04
T1 (1000) 4,1 7  31000  1  T1 (1000) 4,1 7  3,51000  1 

cauce con 4 etapas S1, S2, S3, S4. La alternativa 1 visita las etapas según la secuencia:
S1 S3 S2 S4 S1 S4 S4, y la alternativa 2 en el orden: S1 S2 S3 S4 S3 S4 S2. (A) ¿Cuál de
las dos alternativas permite ejecutar un número mayor de funciones por unidad de
tiempo? Demuestre razonadamente su respuesta. (B) Obtenga además la ganancia en
velocidad que ofrecen cada una de las alternativas con respecto a su ejecución sin cauce
para 1000 operaciones, teniendo en cuenta que sin cauce la función requiere un tiempo
de 15 ns; que las etapas del cauce suponen unos tiempos de ejecución de: 4ns para S1,
4 ns para S2, 3 ns S3 y 4 ns para S4; y que los registros introducen retardos de 0.1 ns.
Solución.
1 2 3 4 5 6 7 1 2 3 4 5 6 7
S X X S X
1 1
S X S X X
2 2
S X S X X
3 3
S X X X S X X
4 4
F1 = {1,2,3,4} C1 = (1111) F2 = {2,5} C2 = (10010)

3, 6+
4 10010 1
3
1111 3, 6+ 6+
5+ 10011 11011
4 3
1 3  3 
MLM1 = 5 MLM 2   2,3
3
n n 1
n n T ( n ) n  TLI  MLM ( n  1) MLM
1 1 1 1
W1 max    0,2 instr/ciclo W2 max     0,43 instr/ciclo
MLM 1 5 MLM 2 2,3
con lo que podemos concluir que la segunda alternativa es mejor que la primera.
tenemos que:

secuencial es de:
TSec (1000) 15000 T (1000) 15000

S1 (1000)   S2 (1000
0,73 )  Sec   1,56
T1 (1000) 4,1 7  51000  1  T2 (1000) 

4,1 7  2,31000  1 

cauce con 4 etapas S1, S2, S3 y S4. La alternativa 1 visita las etapas según la secuencia
S1 S3 S1 S3 S2 S3 S4, y la alternativa 2 en el orden S1 S2 S3 S4 S2 S3. (A) ¿Cuál de las
dos alternativas permite ejecutar un número mayor de funciones por unidad de tiempo?
Demuestre razonadamente su respuesta. (B) Obtenga además la ganancia en velocidad
que ofrece cada una de las alternativas con respecto a su ejecución sin cauce para 500
operaciones, teniendo en cuenta que sin cauce la función requiere un tiempo de 15 ns;
que las etapas del cauce suponen unos tiempos de ejecución de: 4 ns para S1, 5 ns para
S2, 2 ns para S3 y 4 ns para S4; y que los registros de acoplo entre etapas introducen un
retardo de 0.25 ns.
Solución.
1 2 3 4 5 6 7 1 2 3 4 5 6
S X X S X
1 1
S X S X X
2 2
S X X X S X X
3 3
S X S X
4 4
F1 = {2,4} C1 = (1010) F2 = {3} C2 = (100)

3
3 1010 1 2 100 4
1
5
1
1011 1111 101 110 111
3 2
MLM1 = 3 MLM2 = 2
n n 1
n n T (n) n   TLI  MLM ( n  1) MLM
1 1 1 1
W1 max    0,3 W 2 max    0,5
MLM 1 3 MLM 2 2
con lo que podemos concluir que la segunda alternativa es mejor que la primera.
tenemos que:
secuencial es de:
T Sec (500) 7500 T (500) 7500

S 1 (500)   S02,(95
500)  Sec   1,42
T1 (500) 5,25 7  3 500  1  T2 (500) 5,25 6  2 500  1 
La tabla de reservas que se muestra a continuación corresponde a un cauce que puede
ejecutar dos funciones, A y B. Determine las latencias prohibidas y construya el
diagrama de estados para dicho cauce.
t0 t1 t2 t3 t4
S1 A B A B
S2 A B A
S3 B AB
Solución.
Los conjuntos de latencias prohibidas y los vectores de colisiones cruzadas para las
secuencias de instrucciones AA, BA, AB, y BB son los siguientes:
FAA = {3} Representan las latencias prohibidas que aparecen al introducir una
instrucción A, para las instrucciones de tipo A que se quieran introducir
después.
FBA = {1,2} Representan las latencias prohibidas que aparecen al introducir una
instrucción A, para las instrucciones de tipo B que se quieran introducir
después.
FAB = {1,2,4} Representan las latencias prohibidas que aparecen al introducir una
instrucción B, para las instrucciones de tipo A que se quieran introducir
después.
FBB = {2,3} Representan las latencias prohibidas que aparecen al introducir una
instrucción B, para las instrucciones de tipo B que se quieran introducir
después.
Puesto que el valor mayor de latencia prohibida incluida en los conjuntos anteriores es
4, los vectores de colisiones tendrán 4 componentes y serán:
CAA = (0100) (tienen un 1 en la componente 3: las componentes se numeran

desde 1 empezando por la derecha)
CBA = (0011)
CAB = (1011)
CBB = (0110)
Las matrices de colisiones cruzadas son:

CAA 0100
MA = =
CBA
0011
CAB 1011
MB = =
CBB
0110
y el diagrama de estados obtenido a partir de ellas:
A5
A4 B5
B3, B4
0100 1011
0011 0110 B4
A3
A4
A2
A1 A4 A2 B4 B1
0110 0101 1111

0011 0011 0111
A1
A4 0111
0011 B3,B4
En el diagrama anterior, desde cualquier estado se pasa al estado inicial indicado por M A
(MB) cuando se introduce una instrucción A (B) en el cauce tras esperar 5 o más ciclos.
Ese es el significado de la flecha que llega a MA (MB) marcada con A5 (B5).

Las cuatro etapas S1,S2,S3,S4 de un cauce multifuncional se utilizan por las
instrucciones del tipo A de la forma S1,S2,S1,S3,S1,S4,S1 y por las instrucciones del
tipo B de la forma S1,S4,S1,S3,S1,S2,S1. Escriba las matrices de colisiones cruzadas y
determine cuál es la productividad máxima del cauce para una secuencia de
instrucciones del tipo A (es decir A,A,A,......) teniendo en cuenta que la frecuencia de
reloj es de 500 MHz.
Solución.
El primer paso para calcular las matrices de colisiones cruzadas es obtener la tabla de
reservas:
1 2 3 4 5 6 7
S1 AB AB AB AB
S2 A B
S3 AB
S4 B A
Con esta tabla es fácil obtener las latencias prohibidas y los vectores de colisiones del
cauce:
FAA = {2, 4, 6} CAA = (101010) FAB = {2, 4, 6} CAA = (101010)

FBA = {2, 4, 6} CBA = (101010) FBB = {2, 4, 6} CBA = (101010)
Con lo que las matrices de colisiones del cauce quedan como:
101010   101010 
M A    M B   
101010   101010 
Para calcular la productividad máxima para una secuencia del tipo A, solo debemos
tener en cuenta el vector de colisiones CAA = (101010), que nos genera el siguiente
diagrama de estados:
1 5
101010
5
3 5
7
111111 101111 101011
La mínima latencia mínima del diagrama se puede obtener como:
1 7 5  3
MLM    4 cilos
2 2
Con lo que para una secuencia de n operaciones la productividad del cauce es de:
n n n  500 10 6
W ( n)   
T (n) TLI  MLM (n  1) 7  4(n  1)
y la productividad máxima se obtendrá calculando el límite de W(n) cuando n → ∞:
n  500 10 6
W max  lim W (n)  lim  125 MOPS
n  n  7  4( n  1)
Se tiene un cauce multifuncional con 4 etapas, S1,S2,S3,S4, que puede ejecutar dos
tipos de operaciones, A, y B. Las instrucciones del tipo A recorren el cauce según la
secuencia:
S1,S3,S2,S3,S1,S4
y las del tipo B según:
S1,S4,S1,S2,S3,S4
¿Cuál es la mínima latencia media para la secuencia de operaciones ABABABAB....?.

Si la frecuencia de reloj es de 1 GHz, ¿Cuál es la productividad máxima del cauce para
esa secuencia?.
Solución.
Para determinar la mínima latencia media de la secuencia de instrucciones se parte de la
tabla de reservas:
S1 A B B A
S2 A B
S3 A A B
S4 B AB
La lista de latencias prohibidas es
FAA = {2,4}
FBA = {2,4}
FAB = {1,2,3}
FBB = {2,4}
Puesto que el valor mayor de latencia prohibida incluida en los conjuntos anteriores es
4, los vectores de colisiones tendrán 4 componentes y serán:
CAA = (1010) (tienen un 1 en las componentes 2 y 4: las componentes se

numeran desde 1 empezando por la derecha)
CBA = (1010)
CAB = (0111)
CBB = (1010)
Las matrices de colisiones cruzadas son:
CAA 1010
MA = =
CBA
1010
CAB 0111
MB = =
CBB
1010
A partir de las matrices de Colisiones cruzadas, se puede obtener el diagrama de estados

posibles en el cauce para la secuencia de instrucciones ABABAB....
Debido a que la primera instrucción es del tipo A, se partirá del estado asociado a MA.
Desde ese estado se considerarán los posibles estados a los que se podría pasar cuando
llega una instrucción del tipo B (utilizando la matriz MB para generarlos), y así
sucesivamente. El diagrama generado es el siguiente:
A
(c) B5+
1010 0111
1010 1010
A4+
A4+
A4+
(b) B3
B1 (a)
0111 0111
1011 1111
El ciclo que presenta la mínima latencia media es el que se ha designa como (a), que
tiene una latencia total de 1+4 =5 ciclos, y una latencia media de 5/2=2.5, los otros
ciclos tienen latencias medias de 3.5, el (b), y 4.5 el (c). Teniendo esto en cuenta, la
productividad del máxima del cauce es:
Wmax = 1 / (T * MLM) = 1000x106 (ciclos/sg.) / (2.5 ciclos/operación) =
= 400x106 op./sg = 400 MOPS

En un cauce multifuncional con la tabla de reservas siguiente, ¿cuál es el tiempo
mínimo (en ciclos) que tardaría en ejecutarse la secuencia de seis instrucciones
ABCBAC si se utiliza una estrategia de tipo avaricioso?
t0 t1 t2 t3
S1 AC BC
S2 ABC A A
S3 B C
Solución.
A partir de la tabla de reservas del enunciado se pueden obtener las latencias prohibidas
del cauce y las matrices de colisiones para las tres operaciones:
FAA = {1, 2} FAB = {2} FAC = {2}

FBA = {1, 2} FBB = {} FBC = {2}
FCA = {1, 2} FCB = {2} FCC = {2}
 1 1 1 0 1 0
     
MA   1 1 MB  0 0 MC  1 0
 1 1 1 0  1 0 
   
Siguiendo una planificación avariciosa del cauce, se pasarían por los siguientes estados:
A
11 A3 11
11 01
11 11
C3 B1
B3
10 10 C1 11
10 00 10
10 10 11
Por lo que el tiempo total de ejecución de la secuencia sería de 16 ciclos, como si indica
en el siguiente diagrama de tiempos:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
A
B
C
B
A
C

En un cauce multifuncional con la tabla de reservas siguiente ¿Cuál es el tiempo
mínimo que tardaría en ejecutarse la secuencia de instrucciones ACCABB si se utiliza
una estrategia de tipo avaricioso?
t0 t1 t2 t3
S1 AC B
S2 ABC B A
S3 B AC
Solución.
Las listas de latencias prohibidas son:
FAA = {2} FAB = {1,2} FAC = { }
FBA = {1,2} FBB = {1} FBC = {2}
FCA = {2} FCB = {1,2} FCC = { }
Por lo tanto, las matrices son
10 11 00
MA = 11 MB= 01 MC= 10
10 11 00
C1 C2 A1 B3 B2
A 1 0 0 1 1 1
0 1 0 0 1 1
1 1 1 1 0 0
1 1 0 1 1 1
1 0 0 1 1 1
0 1 0 0 1 1
1 2 3 4 5 6 7 8 9 10 11 12
A
C
C
A
B
B
El número de ciclos total es de 12

Se tiene un cauce multifuncional con 4 etapas, S1, S2, S3, S4, que puede ejecutar dos
tipos de operaciones, X, e Y. Las operaciones del tipo X recorren el cauce según la
secuencia S2, S4, S3, S1, S1, S2, mientras que las de tipo Y lo hacen en el orden
S1, S2, S1, S2, S3, S4. El bucle interno de un programa realiza intensivamente la
secuencia de operaciones X, Y, Y, X, X, Y, Y, Y.
¿Cuánto tiempo tardaría en ejecutarse el cuerpo del bucle si la frecuencia de reloj es de
1 GHz?, ¿Cuál es la productividad máxima del cauce para esa secuencia?
Solución.
El primer paso para resolver el problema es determinar la tabla de reserva del cauce:
1 2 3 4 5 6
S1 Y Y X X
S2 X Y Y X
S3 X Y
S4 X Y
A partir de esta tabla podemos determinar las matrices de colisiones del cauce:
1 0 0 0 1 0 1 1 1 1
M X    M Y   
0 1 1 1 1 0 0 0 1 0 
Como en el enunciado nos piden que calculemos cuánto tiempo tarda en ejecutarse la
secuencia de operaciones X, Y, Y, X, X, Y, Y, Y, no tenemos que dibujar el diagrama de
estados completo, sino sólo la parte que se utiliza para determinar las latencias de esta
secuencia. A continuación se muestra dicha parte.
X (1)
X5 (1- Sig. Iter.)

10001 01111
01111 00010
Y5 (2)
X2 (5) Y1 Y3 (8) X5 (4)

(3,7)
Y5 (6)
10101 01111
01111 00011
El tiempo que tarda en ejecutarse esta secuencia es igual a 27 ciclos, como se puede
calcular con ayuda de la siguiente gráfica:
X
Y
Y
X
X
Y
Y
Y
Siguiente iteración del bucle
1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2
1 2 3 4 5 6 7 8 9
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8
Por lo tanto, si el reloj va a 1 GHz, la secuencia de operaciones tardará 28

nanosegundos.
Para calcular la productividad máxima para esta secuencia tenemos que tener en cuenta
que la siguiente iteración no puede comenzar hasta el ciclo 28, ya que tenemos que
esperar 5 ciclos después de la última Y para introducir la X de la siguiente secuencia,
como indica el diagrama de estados, así que podremos empezar una nueva secuencia
cada 27 ciclos, por tanto, el tiempo para calcular n secuencias será:
T(n) = TLI + MLM·(n – 1) = 28 + 27(n – 1)
La productividad máxima será :
n n 1
W max  lim  lim  ciclos 1
n  T (n ) n   28  27( n  1) 27
Es decir, que podremos producir una secuencia cada 26 ciclos. Como la secuencia está
compuesta por 8 operaciones, la productividad máxima en operaciones por segundo
sería:
1 secuencia  8 instr/sec
W max   296,296 MOPS
27 ciclos  10 -9 s/ciclo
Un procesador segmentado tiene 5 etapas S1, S2, S3, S4, S5 y todas tardan un ciclo
excepto la etapa S3 (etapa de ejecución) que, según las instrucciones puede tardar 2 o 3
ciclos. ¿Cuál es la velocidad pico de ese procesador si funciona a 500 MHz? ¿Qué
mejora podría implementar para mejorar esa velocidad pico? ¿Qué valor alcanzaría
entonces?
Solución.
(a) Teniendo en cuenta que una etapa dura dos ciclos para un tipo de instrucciones y tres
ciclos para otro tipo, en el mejor de los casos (si todas olas instrucciones del programa
son de aquellas en las que la etapa S3 duran dos ciclos), se puede terminar una
instrucción cada dos ciclos.
Por tanto, la velocidad pico se puede estima a partir de:
1(instruccio
n)
V pico * 500* 106(ciclos .) 250* 106(instruccio
/ sg nes .) 250
/ sg MIPS
2(ciclos
)
Este apartado se podría resolver de forma más rigurosa a partir de las latencias
prohibidas del cauce (teniendo en cuenta que es un cauce multifuncional). Así, la tabla
de reservas para la situación descrita es la siguiente:
S1 AB
S2 AB
S3 AB AB B
S4 A B
S5 A B
La latencias prohibidas son:
FAA = {1} FBA = { 1 }
FAB = {1,2} FBB = {1,2}
y el diagrama de estados será:

A,2 B,3
MA
01 11
01 11
MB
B,3
A,2
Donde se puede comprobar fácilmente que cualquier ciclo que se construya tiene una
latencia media que estará entre 2 (como mínimo) y 3 (como máximo). Por lo tanto, la
velocidad pico corresponderá a la situación e que la MLM (mínima latencia media) es
igual a 2, tal y como se había estimado antes.
(b) Para mejorar la velocidad del procesador, una posible mejora consiste en añadir
varias etapas S3 que puedan funcionar simultáneamente, tal y como muestra la figura.
S3
S1 S2 S3 S4 S5
S3
Además de añadir estas dos etapas S3 adicionales, habría que mantener las instrucciones
de tipo A en la etapa S3 durante tres ciclos en lugar de dos ciclos.
Otra posibilidad consiste en rediseñar la etapa S3 de forma que conste de tres etapas
independientes de un ciclo cada una de ella. En este caso, también debe ocurrir que las
instrucciones de tipo A pasn por las tres etapas nuevas.
Con cualquiera de estas modificaciones, el tiempo de latencia de cualquier instrucción

es de 7 ciclos, y cada ciclo terminaría de ejecutarse una instrucción. De esta forma, la
velocidad pico sería:
1(instruccio
n)
V pico * 500* 106(ciclos .) 500* 106(instruccio
/ sg nes .) 500MIPS
/ sg
1(ciclo
)

Un sumador segmentado con cuatro etapas S1,S2,S3,S4 tiene la siguiente tabla de
reservas:
t0 t1 t2 t3 t4
S1 X X
S2 X
S3 X X
S4 X
Indique cuál es la productividad máxima de este cauce si se utiliza un reloj con una
frecuencia de 2 GHz. ¿A partir de qué número de sumas segmentadas consecutivas se
alcanza el 90% de la productividad máxima. ¿Qué cambios haría en la etapa S3 para
mejorar el rendimiento del cauce?
Solución.
La lista de latencias prohibidas es F={1,4} y por lo tanto C=(1001)
Por lo tanto, el diagrama de estados es:

3, 5+
1001
3, 5+ 2
1011
Por lo tanto la mínima latencia media es MLM = (2+3)/2=2.5
La productividad es:
W (n) = n / (TLI + MLM * t * (n-1)) = n /(2.5 + 1.25 * (n-1))
donde se ha considerado que t =0.5 ns y TLI = 5*t = 5* 0.5 = 2.5 ns
Por tanto, la productividad máxima es Wmax = limn→∞W(n) = 1/1.25 ns-1
Para determinar el valor de n con el que se alcanza el 90% de la productividad máxima

se despeja n de la igualdad:
0.9 Wmax = 0.9 * 1/1.25 = n /(2.5 + 1.25 * (n-1))
obteniéndose n=9.
Un cambio posible en la etapa S3 es segmentarla. Así, en ligar de 4 se tendrían 5 etapas
t0 t1 t2 t3 t4
S1 X X
S2 X
S3 X
S3’ X
S4 X
Con lo que la única latencia prohibida sería F=4. Si se hace el diagrama de estados
partiendo de C=(1000) se observa que la mínima latencia media que se obtiene en este
caso es menor que 2.5.

Segmentación

Cargado por

Copyright:

Formatos disponibles

Segmentación

Cargado por

Información del documento

Descripción original:

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

Segmentación

Cargado por

Copyright:

Formatos disponibles

Capítulo 2: Segmentación

Ganancias, productividad, fijar CLK

Las expresiones de la ganancia, S(n), y la productividad, W(n), para n operaciones

S(n) = Tsin_segmentación (n) / Tcon_segmentación (n)

W(n) = n / Tcon_segmentación (n)

Tsin_segmentación (n) = n * Top = n * 450 ns.

Tcon_segmentación (n) = (Número_de_etapas * T) + (n-1) * T = 4*150+(n-1)*150 ns.

siendo el tiempo de latencia de inicio del cauce, TLI = Número_de_etapas*T= 4*150 ns

Sustituyendo en las expresiones de la ganancia y la productividad se tiene que

S(n) = (450 * n) / (600 + 150*(n-1))

W(n) = n / (600 +150*(n-1)) ns -1

Smax = 450 / 150 = 3 Wmax = 1 / 150 ns –1

El valor de n para el que se alcanza un 90% de la productividad se calcula despejando n

0.9 * Wmax = n / (600 + 150 * (n-1)) → n = 27 operaciones ejecutadas

se ejecuta en un procesador segmentado con etapas IF (captación de instrucciones), ID

Si el tiempo de latencia del multiplicador fuese 1 ciclo, entonces no se perdería ningún

Tiempo=Tiempo de latencia de la primera instrucción + Un ciclo por cada instrucción

- Instrucción (2) y (4) en r2

Considerando que no existen caminos de bypass (y que el tiempo de la multiplicación es

- El RAW (6)-(8) ocasiona 1 ciclo perdido pero al retrasar la captación de (9)

(Se pueden comprobar los resultados simulando el programa mediante WinDLX).

En este ciclo no termina ninguna instrucción (la

Este resultado se puede comprobar mediante el simulador WinDLX. Si se realiza la

Se puede reducir un ciclo (similares prestaciones que en la situación inicial del

start: ld f0,a (1)

donde RX y RY son las direcciones de memoria a partir de las que se encuentran,

En la etapa EX del ciclo 10 de la figura se indican dos instrucciones: una se está

El tiempo de ejecución de una iteración es de 16 ciclos (desde que se capta la

Al simular el programa en WinDLX se obtiene que T(N=64) = 1031 ciclos,

Una forma de mejorar las prestaciones del programa es desenrollar el bucle. En el

start: ld f0,a (1)

En el código anterior los números de instrucciones (5’),..., (11’) designan a las

Para determinar el tiempo tardaría en ejecutarse el programa en este caso, se puede

Tdesenrollado1(N) = 7 + 28*(N/2) = 7 + 14*N

Se puede reducir algo más el tiempo de ejecución si se reordenan las instrucciones en el

start: ld f0,a (1)

Tdesenrollado2(N) = 7 + 19*(N/2) = 7 + 9.5*N

Después, la instrucción (5) carga f2 con la primera componente de X, y se multiplica

La instrucción (10) realiza la suma de la primera componente de aX y la primera de Y.

Dentro del bucle:

- En la primera iteración la instrucción (11) realiza el almacenamiento del

- En la última iteración, (11) almacena la última componente del resultado; (12) y

- En el bucle, se han reordenado las instrucciones para evitar el efecto de los

4 (primeras cuatro etapas de la primera instrucción) +

(2) Restantes 63 iteraciones de (11) – (19)

4 (primeras cuatro etapas de la primera instrucción del bucle) +

(3) Ciclos hasta que termina la última instrucción: 3 (o 4 si se cuenta la instrucción

En función de N, se tendría T(N) = 16 + 14 N. Es decir, que la reducción de tiempo

En cualquier caso, es posible obtener mejores prestaciones todavía si se reorganizan

start: ld f0,a (1)

Según esto, el tiempo de ejecución es:

T(64) = 22 (primera ejecución de (1) – (19)) +

(Nota: Los tiempos obtenidos se pueden comprobar mediante simulación de los

En el ejemplo que se muestra a continuación, la instrucción de carga de f2 con r8 se

start: ld f0,a (1)

start: ld f0,a (1)

7 (Benchmark diciembre 2007)

for (i=0 ; i<n ; i++)

Tcon_segmentación (n) = (Número_de_etapas * T) + (n-1) * T = 4150+(n-1)150 ns.

siendo el tiempo de latencia de inicio del cauce, TLI = Número_de_etapasT= 4150 ns

Tdesenrollado1(N) = 7 + 28(N/2) = 7 + 14N

Tdesenrollado2(N) = 7 + 19(N/2) = 7 + 9.5N