Capítulo 6: Vectoriales

1 (Ejercicios de clase)
La memoria principal de un procesador vectorial con capacidad de 16 Mpalabras se
encuentra distribuida entre 8 módulos utilizando entrelazado de memoria de orden
inferior y acceso de tipo S. Suponiendo que el compilador ha almacenado en memoria,
por filas, una matriz 4x4, obtenga: (a) Las posiciones de memoria en las que se sitúa la
segunda columna de la matriz teniendo en cuenta que la matriz comienza a partir de la
posición A6BBh. (b) ¿Puede el procesador leer la segunda columna realizando un único
acceso a memoria? ¿Por qué?

Solución.
(a) Puesto que la memoria tiene 16 Mpalabras, las direcciones serán de 24 bits, y como
se encuentra distribuida en 8 módulos con entrelazado de orden inferior, los 3 bits (23=8
módulos) menos significativos de la dirección indican el módulo en que se encuentra la
palabra direccionada.

Así pues, la dirección de inicio de la matriz 4x4,

A6BBh = 0000 0000 1010 0110 1011 1011

se encuentra en el módulo 3 (011), y dentro de ese módulo en la posición (los restantes

21 bits más significativos de la dirección):
0000 0000 1010 0110 1011 1

Según esto, y teniendo en cuenta está almacenada por filas, la matriz se situará en la
memoria según se indica en la siguiente tabla, donde se indican en gris las posiciones
donde están los elementos de la columna 2

Dirección en el módulo Módulos

0 1 2 3 4 5 6 7
(000) (001) (010) (011) (100) (101) (110) (111)
0000 0000 1010 0110 1011 1 (1,1) (1,2) (1,3) (1,4) (2,1)
0000 0000 1010 0110 1100 0 (2,2) (2,3) (2,4) (3,1) (3,2) (3,3) (3,4) (4,1)
0000 0000 1010 0110 1100 1 (4,2) (4,3) (4,4)

Esto quiere decir que las direcciones de los elementos son (uniendo los 21 bits más
significativos que indican la profundidad dentro del módulo en la primera columna de la
tabla, con los bits que indican el módulo en la columna correspondiente):

(1,2) 0A6BCh
(2,2) 0A6C0h
(3,2) 0A6C4h
(4,2) 0A6C8h
(b) puesto que las posiciones de los elementos de la columna están en tres
profundidades diferentes y el acceso es de tipo S, en el que se pueden leer en el mismo
acceso las palabras que estén a la misma profundidad, se necesitarán tres accesos a
memoria. No se puede acceder a la comuna en un sólo acceso.

2 (Ejercicios de clase)
En la situación del problema anterior, obtenga el tiempo mínimo que necesitaría el
procesador vectorial para acceder a la segunda columna de la matriz suponiendo una
frecuencia de 100 Mhz y un tiempo de acceso a memoria Ta=8t, donde t es el tiempo de
ciclo del procesador.

Solución.
Teniendo en cuenta que el acceso es de tipo S y los elementos de la columna están a tres
profundidades diferentes, se necesitarán tres accesos.

Considerando que se desea acceder a los elementos de la columna de forma ordenada,

en el primer acceso se podrá leer el elemento (1,2) necesitándose un tiempo Ta.
Mientras se lee el elemento del búfer correspondiente se realiza el segundo acceso para
leer los elementos (2,2) y (3,2). Finalmente, mientras se extraen esos elementos de los
correspondientes búferes, se realiza el tercer acceso para leer el elemento (4,2). Al
terminar el acceso, hay que extraer el elemento (4,2) del búfer, necesitándose un tiempo
t. En la Figura 5.7 se esquematiza la secuencia de accesos a memoria.

t (1,2)
t t (2,2) (3,2)
Ta t (4,2)
Ta
Ta
Figura 5.7 Secuencia de accesos a memoria para leer la columna 2 de la matriz

Por lo tanto el tiempo total para acceder a la columna es:

Tcolumna(2) = 3*Ta +t = 3*(8*t)+t = 25*t

Teniendo en cuente que la frecuencia es de 100 MHz, t= 10 ns, y el tiempo será

Tcolumna(2) = 25*10 = 250 ns

3 (Examen septiembre 2005)

Se dispone de una memoria de 8 Mbytes con entrelazado de orden inferior y acceso de
tipo S (simultáneo) distribuida en módulos de 256 Kbytes. Se ha almacenado un vector
de 138 componentes en posiciones de memoria consecutivas a partir de la posición
34BC5h. ¿Cuántos accesos se necesitan para leer el vector completo? ¿Y si el
entrelazado fuera de orden superior (manteniendo el acceso de tipo S)?
 Solución.
El primer paso para resolver este problema es ver cómo se encuentran repartidos los
elementos del vector entre los módulos de memoria. Tenemos una memoria de 8 MB =
223 Bytes, repartida en módulos de 256 KB = 218 Bytes, lo que quiere decir que
tendremos un total de 25 = 32 módulos de memoria. Si se utiliza entrelazado inferior y
acceso tipo S para acceder a ellos, las posiciones de memoria consecutivas se
encontrarán en módulos de memoria consecutivos, y como hay 32 módulos, en el
módulo 0 estarán todas las direcciones múltiplo de 32, 0x20 en hexadecimal. Teniendo
esto en cuenta, y que el mayor múltiplo de 0x20 por debajo de 0x34BC5 es 0x34BC0,
los datos estarán colocados en las posiciones de memoria sombreadas de la siguiente
figura:

Direcció 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
00
n 1 2 3 4 5 6 7 8 9 A B C D E F 0 1 2 3 4 5 6 7 8 9 A B C D E F
0x34BC0
0x34BE0
0x34C00
0x34C20
0x34C40

Con lo que para acceder a todos los datos del vector tendremos que generar las 5
direcciones de la primera columna de la tabla anterior, es decir, que son necesarios 5
accesos a memoria.

En el caso de que se utilizara entrelazado superior, las posiciones de memoria

consecutivas se encontrarían en el mismo módulo. Tanto la dirección de comienzo como
la de final del vector se encontrarían en el módulo de memoria 0, que contendría las
posiciones de memoria desde la dirección 0x000000 a la 0x40000, con lo que harían
falta 138 accesos a memoria, tantos como componentes, para leer el vector.

4 (Examen septiembre 2006)

Se dispone de una memoria de 16 Mbytes con entrelazado de orden inferior y acceso de
tipo S (simultáneo) distribuida en módulos de 512 Kbytes. Se ha almacenado un vector
de 113 componentes en posiciones de memoria consecutivas a partir de la posición
21BC5h. ¿Cuántos accesos se necesitan para leer el vector completo? ¿Y si el
entrelazado fuera de orden superior (manteniendo el acceso de tipo S)?

Solución.
El primer paso para resolver este problema es ver cómo se encuentran repartidos los
elementos del vector entre los módulos de memoria. Tenemos una memoria de 16 MB =
224 Bytes, repartida en módulos de 512 KB = 219 Bytes, lo que quiere decir que
tendremos un total de 25 = 32 módulos de memoria. Si se utiliza entrelazado inferior y
acceso tipo S para acceder a ellos, las posiciones de memoria consecutivas se
encontrarán en módulos de memoria consecutivos, y como hay 32 módulos, en el
módulo 0 estarán todas las direcciones múltiplo de 32, 0x20 en hexadecimal. Teniendo
esto en cuenta, y que el mayor múltiplo de 0x20 por debajo de 0x021BC5 es 0x034BC0
(escribimos las direcciones con 6 dígitos para hacer hincapié en que la memoria tiene 16
MB, y que por tanto, se direcciona con direcciones de 24 bits o 6 dígitos
hexadecimales), los datos estarán colocados en las posiciones de memoria sombreadas
de la siguiente figura:
 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
Dirección 00
1 2 3 4 5 6 7 8 9 A B C D E F 0 1 2 3 4 5 6 7 8 9 A B C D E F
0x021BC0
0x021BE0
0x021C00
0x021C20

Con lo que para acceder a todos los datos del vector tendremos que generar las 4
direcciones de la primera columna de la tabla anterior, es decir, que son necesarios 4
accesos a memoria.

En el caso de que se utilizara entrelazado superior, las posiciones de memoria

consecutivas se encontrarían en el mismo módulo. Tanto la dirección de comienzo como
la de final del vector se encontrarían en el módulo de memoria 0, que contendría las
posiciones de memoria desde la dirección 0x0000000 a la 0x03FFFF (2 19 – 1), con lo
que harían falta 113 accesos a memoria, tantos como componentes, para leer el vector.

5 (Ejercicios de clase)
Un procesador vectorial con registros vectoriales de 8 elementos tiene una memoria de
1 Mpalabra distribuida entre 8 módulos con entrelazado de orden superior y acceso de
tipo C. Suponiendo que la primera componente se encuentra en la posición AA012h,
¿en qué posiciones situaría los restantes 7 componentes para que el acceso a dicho
vector sea lo más rápido posible?

Solución.
Teniendo en cuenta que la memoria tiene una capacidad de 1 Mpalabra la dirección de
palabra consta de 20 bits, y como está distribuida en 8 módulos con entrelazado
superior, la dirección de módulo corresponde a los 3 bits más significativos. En la
Figura 5.6 se muestra la distribución de bits de direcciones y la estructura de
interconexión para el acceso tipo C.

a19 a17 a16 a0

módulo posición en el módulo

Señales
R/W Ocupado/
Completo M7 M6 M0

Registros de
Direcciones y
Controlador control
de Memoria
a19
a18 decod
a17
a16

a[16:0]
a0
Entrelazado Superior y Acceso C
Figura 5.6 Direcciones y estructura para el acceso C
La dirección del primer elemento a cargar en memoria es:

AA012h = 1010 1010 0000 0001 0010

Por lo que los tres bits más significativos son 101, indicando que se encuentra en el
módulo 5 (101) a la profundidad

0 1010 0000 0001 0010

Para que el acceso sea lo más rápido posible, teniendo en cuenta que el acceso es tipo C,
la única restricción es que las direcciones de los demás elementos se encuentren en
módulos de memoria diferentes. Además, aunque es lógico considerar que los 8
elementos 0,1,2,..,7 del vector se encuentren en direcciones crecientes de memoria, esto
es contradictorio con la necesidad de que el acceso sea lo más rápido posible ya que al
utilizarse entrelazado superior posiciones de memoria consecutivas estarán en el mismo
módulo. Una forma posible para situarlas es que estén en profundidades consecutivas

Según esto, las direcciones serían:

Componente 0  AA012h = 1010 1010 0000 0001 0010

Componente 1  1100 1010 0000 0001 0010 = CA012h
Componente 2  1110 1010 0000 0001 0010 = EA012h
Componente 3  0000 1010 0000 0001 0011 = 0A013h
Componente 4  0010 1010 0000 0001 0011 = 2A013h
Componente 5  0100 1010 0000 0001 0011 = 4A013h
Componente 6  0110 1010 0000 0001 0011 = 6A013h
Componente 7  1000 1010 0000 0001 0011 = 8A013h

Con lo que se han introducido las componentes del vector en los 8 módulos y a dos
profundidades distintas (la 0 1010 0000 0001 0011 y la 0 1010 0000 0001 0010.

El tiempo de acceso a la línea será Ta+8 es decir, el tiempo de acceso a memoria para
captar la primera palabra, más un tiempo  necesario para extraer la componente leída
desde los circuitos de acceso a memoria.

6 (Examen diciembre 2004)

En un procesador vectorial a 2 GHz, con registros vectoriales de 8 componentes, una
única unidad de carga/almacenamiento de memoria (LV/SV), un único multiplicador y
un único sumador, se ejecuta el bucle:

for (i = 0 ; i < n ; i++) Y [i] = a*X [i][0] + b;

donde Y es un vector de n elementos y X es una matriz de n filas por 6 columnas

almacenada por filas. Si la memoria de este computador está separada físicamente en 8
módulos accedidos con entrelazado inferior, (a) Determine en qué posición de cada
módulo de memoria estará colocada cada componente de la primera columna de X si
X[0][0] está colocado en la posición 0x00120 y n = 8. (b) Con esta colocación de los
elementos de X en memoria, ¿cuál sería el tiempo de latencia inicial (TLI) y el tiempo
por componente (TPC) para la lectura de la primera columna de X si el acceso a
memoria es de tipo C y el tiempo de acceso para cada módulo es Ta = 8 ciclos?

Solución.
Para responder al primer apartado, dibujaremos el contenido de la memoria desde la
posición 0x00120, en la que se encuentra X[0][0], hasta la posición 0x0014F, en la que
se encuentra X[7][5], ya que X es una matriz de 6 columnas por 8 filas (n = 8).

0 1 2 3 4 5 6 7
0x00120 X00 X01 X02 X03 X04 X05 X10 X11
0x00128 X12 X13 X14 X15 X20 X21 X22 X23
0x00130 X24 X25 X30 X31 X32 X33 X34 X35
0x00138 X40 X41 X42 X43 X44 X45 X50 X51
0x00140 X52 X53 X54 X55 X60 X61 X62 X63
0x00148 X64 X75 X70 X71 X72 X73 X74 X75

Con esta colocación de los elementos, un acceso a memoria concurrente (tipo C) no

podrá servirnos la primera columna de X a un ritmo de una componente por ciclo, ya
que se puede comprobar que tenemos contención de memoria en los módulos 0, 2, 4 y
6. Por tanto, se podrán solapar las cuatro primeras lecturas, pero las cuatro siguientes se
tendrán que retrasar hasta que terminen las primeras, gráficamente

Módulo 0 (Ta = 8) X00

Módulo 6 (Ta = 8) X10
Módulo 4 (Ta = 8) X20
Módulo 2 (Ta = 8) X30
Módulo 0 (Ta = 8) X40
Módulo 6 (Ta = 8) X50
Módulo 4 (Ta = 8) X60
Módulo 2 (Ta = 8) X70
Módulo 0 (Ta = 8)

8 Contención Contención

En consecuencia, podemos concluir que debido a la colocación de los datos en

memoria, para acceder a la primera columna de X tendremos un TLI = 8 (igual al
tiempo de acceso a memoria) y un TPC = 2, ya que para cada cuatro datos empleamos
cuatro ciclos en su lectura más otros cuatro ciclos de contención, por tanto, para leer n
datos colocados en memoria de esta forma emplearíamos:

T(n) = TLI + n · TPC = 8 + 2n ciclos

7 (Ejercicios de clase)
Suponiendo que el tiempo de latencia de inicio (start-up), TLI, para una multiplicación
vectorial es de 10 ciclos de reloj y que después, el tiempo por resultado, TPC, es de 1
ciclo de reloj. ¿Cuál es el número de ciclos de reloj por resultado, CPR, para un vector
de 64 componentes?
Solución.
Aplicando la expresión del tiempo de cálculo vectorial TCV

TC V  TLI  K *TPC

se tiene que TCV = 10 + 64*1 = 74 ciclos, y por lo tanto el número de ciclos por
resultado es

TCV 74
C PR    1 .1 5 6
K 64

Por lo tanto, cada operación de multiplicación de un componente de cada vector

consume un promedio de 1.156 ciclos.

8 (Ejercicios de clase)
Si el tiempo de latencia de inicio (TLI) para una operación en un cauce vectorial es
(4/3)T, siendo T el tiempo de ejecución de dicha operación sobre un cauce escalar, y el
cauce vectorial genera un resultado cada T/3. ¿Cuál es el valor de Nv (número de
componentes que debe tener un vector para hacer que el modo vectorial sea más rápido
que el escalar) para dicho cauce?

Solución.
En la operación vectorial se tiene que

TCV = TLI + K*TPC = (4/3)T + K (1/3)T = (T/3) (4+K)

El tiempo de ejecución de la operación en modo escalar (TCE) es igual al tiempo de

ejecución de la operación (T) multiplicado por el número de operaciones realizadas (K).

Se pide el valor de Nv, es decir el valor de K para el que TCE ≤ TCV:

T*Nv ≥ (T/3)(4+Nv)

de donde

(4/3) ≤ (2/3)Nv → Nv ≥ 2

Es decir, que a partir de dos componentes, el modo vectorial es más rápido que el
escalar. Esta situación es ideal para un procesador vectorial puesto que el número de
componentes a partir del que interesa realizar la operaciones sobre un conjunto de
números como operación vectorial es el menor posible (dos, es decir más de una
operación a realizar). Las razones de esta situación se pueden encontrar es que el tiempo
de latencia de inicio no es mucho mayor que el tiempo de operación secuencial y el TPC
es reducido (tres veces menor que el tiempo secuencial).
9 (Ejercicios de clase)
Para un valor de TLI fijo, ¿es cierto que, a medida que TPC aumenta, disminuye la
longitud mínima del vector a la que el valor de TLI no es mayor que una fracción de
TCV dada?

Solución.
En el problema se indica que el tiempo de latencia TLI no debe ser mayor que una
fracción dada de TCV, por lo tanto se tiene que:

TLI TLI
  C onst
TC V TLI  K *TPC

donde Const es una constante (TLI es una fracción constante de TCV).

La igualdad anterior se puede expresar como:

T L I * (1  C o n s t )
K *TPC 
C o n st

Como además, se indica que TLI se mantiene constante, también se mantendrá

invariante la parte derecha de la igualdad anterior:

T L I * (1  C o n s t )
 c
C on st

donde c se mantiene constante también.

Por consiguiente, si

K*TPC = c

cuando TPC crece, K decrece; y si TPC decrece, K crece, como se quería demostrar.

Lo que se ha demostrado significa que, para un valor de TLI dado, a medida que el
cauce es más rápido (es decir, TPC es más pequeño), aumenta la longitud de los
operadores vectoriales necesaria para que el TLI sea un porcentaje prefijado del tiempo
de procesamiento total. Dicho de otra manera, cuanto más rápido genera resultados un
cauce vectorial, más largos tendrán que ser los vectores para hacer despreciable el valor
del tiempo de latencia inicial.

10 (Ejercicios de clase)
Si para un cauce el tiempo de latencia de inicio, TLI, es de 6 ciclos, y el tiempo por
resultado, TPC, es 1 ciclo.¿Cuál ha de ser la longitud mínima del vector que procese ese
cauce para que el TLI no representa más de un 5% del total del procesamiento?

Solución.
Teniendo en cuenta que TLI =6 y TPC=1, se cumple que
 TCV = TLI + K*TPC = 6 + K

Si el tiempo de latencia de inicio no puede ser mayor que el 5% del tiempo total se tiene
que

TLI ≤ 0.05 * TCV → 6 ≤ 0.05 * (6+K)

y despejando,

0.95*6 ≤ 0.05*K → K ≥ (5.7/0.05) = 114

Es decir que, para vectores mayores de 114 componentes se tendrá que el tiempo de
latencia de inicio es menor del 5% del tiempo de cómputo total.

Para que este resultado sea correcto debe cumplirse que el número de componentes de
los registros vectoriales del procesador vectorial sea mayor que 114 (un valor posible y
realista en ciertos procesadores, sobre todo de fabricantes japoneses puede ser 128).

Si el tamaño de los registros vectoriales es menor que 114 (MVL ≤ 114) entonces hay
que explicar la expresión del tiempo de procesamiento para el caso de troceado de
vector:

 K 
T L I  0 .0 5 * ( T B A S E   * (T BUCLE  T L I )  K * T P C
 M V L 

Para poder determinar explícitamente K, habría que conocer los valores de MVL,
TBUCLE, y TBASE. Supondremos valores típicos para ellos, utilizados en problemas
anteriores:

MVL =64 TBUCLE=15 TBASE=10

y sustituyendo

 K 
6  0 .0 5 * ( 1 0    * 2 1  K )
64

Para determinar K:
- Si se supone K ≤ 64 : Al despejar K de la expresión anterior se tiene que K>89,
y no es coherente con la suposición.
- Si se supone 64 < K ≤ 128: Al despejar K de la expresión anterior se tiene que
K ≥ 68, que es coherente con la suposición.

Es lógico que ahora el valor de K sea menor que en el cálculo anterior (68, en lugar de
114) dado que el tiempo de cálculo aumenta al incluirse los tiempos TBUCLE y TBASE.

11 (Ejercicios de clase)
Calcule los valores de Rinf y N1/2 para la secuencia de instrucciones de la figura 5.3
suponiendo que se encuentran dentro de un bucle como resultado de aplicar la técnica
de troceado de vector ('strip minning'). La secuencia de instrucciones tarda un tiempo
TCV=241 ciclos, TPC=3 ciclos, la frecuencia de reloj es de 80 Mhz, y el tamaño de los
registros vectoriales es de 64 componentes. Los valores de los tiempos TLI se dan en la
Tabla 1, TBASE=10, y TBUCLE=15.

TABLA 1
Operación Suma Vectorial Mult. Vectorial División Vect. Carga Vectorial
TLI 6 7 20 12

Operación Comienza (Ciclo) Termina (Ciclo)

Comentario
LV V1,Rx 0 12+64=76Latencia simple
MULTV a,V1 12+1=13 13+7+64=84
Encadenada a LV
LV V2,Ry 76+1=77 77+12+64=153
Comienza después del
primer LV realizado
(contención de mmoria)
ADDV V3,V2,V1 77+1+12=90 90+6+64=160 Encadenada a MULTV y
LV
SV Ry,V3 160+1+4=165 165+12+64=241 Debe esperar en ADDV;
no encadenada
(contención de memoria)
Figura 5.3 Distribución temporal de operaciones

Solución.
Para resolver el problema se parte de la expresión del tiempo de cálculo vectorial
cuando se aplica troceado del vector.

 n 
Tn  T BASE   * (T BU CLE  T L I )  n * T P C
 M V L 

donde, para determinar los parámetros que se necesitan, se tiene en cuenta el tiempo de
procesamiento que se proporciona en la Figura 5.3 para vectores de 64 componentes
(caben en los registros vectoriales del procesador): TCV=241 ciclos

Utilizando el modelo de prestaciones del cauce que definen las operaciones vectoriales
realizadas, TCV=TLI+k*TPC, donde k≤MVL. En este caso MVL=64, y k=64 (Figura
5.3), y como en el enunciado se indica que TPC=3 se puede despejar TLI:

241 = TLI + 64*3 → TLI = 241 – 64*3 = 49

Aunque en el enunciado se proporciona explícitamente el valor de TPC para facilitar la

obtención de TLI, ambos parámetros se pueden obtener a partir de la distribución
temporal de operaciones que se muestra en la Figura 5.3 del enunciado. Esto se puede
hacer a partir del esquema que se muestra en la Figura 5.4 (que no es más que una
representación gráfica de los datos de la Figura 5.3).
 12 64 1+12+1 6 64 1+4+12 64

TCV = (12+1+12+1+6+1+4+12)+3*64
TLI=49 TPC=3
Figura 5.4 Secuencia de operaciones vectoriales (encadenamientos y concurrencia)

Utilizando, además, que TBUCLE=15, TBASE=10, y MVL=64, se tiene que

 n   n 
Tn  1 0    * ( 1 5  4 9 )  3 * n  1 0   6 4  * 6 4  3 * n
64

Como el número de operaciones vectoriales que se realiza es 2 (MULTSV y ADDV), y

teniendo en cuenta que la frecuencia del procesador es de 80 MHz, se tiene que

O p e r a c .V e c t o r .* n * f r e c u e n c i a 2 * n *80
Rn   M FLO PS
T n ( c ic lo s )  n 
10  64 *    3* n
64 

Para determinar el valor de Rinf hay que obtener el límite de Rn. Esto se puede realizar
teniendo en cuenta que se pueden establecer las cotas

2 * n *80 2 * n *80
 Rn 
n n
10  (  1) * 6 4  3n 10  ( )* 64  3* n
64 64

y si se aplican los límites al infinito a la cota inferior y superior, ambas convergen a

(160*n)/(4*n), con lo que Rinf = 40 MFLOPS

Para calcular N1/2 se tiene en cuenta que

1 2 * n *80
R  20 
2 in f
 n 
10   * 64  3* n
64 
y para despejar n, en primer lugar supondremos que n<64 y se comprueba que el
resultado final es coherente con dicha suposición (si no lo fuera habría que comprobar
con n mayor que 64 y menor que 128, y así sucesivamente). Por tanto, para n menor o
igual a 64 se tendría que

20 = (160*n)/(10+64+3*n)

y despejando, n=15. Como es coherente con la suposición realizada se tiene que

N1/2=15. Por tanto, para un tamaño de vector de 15 componentes se obtiene la mitad del
rendimiento máximo del computador vectorial para este problema.

12 (Ejercicios de clase)
Determine el valor de T66 y Rinf para la secuencia de instrucciones del problema anterior,
suponiendo que al añadir dos cauces de acceso a memoria más, TCV=104 ciclos y
TPC=1 ciclo. Los valores de TLI se dan en la Tabla 1, y TBASE=10, y TBUCLE=15.

Solución.
En este problema se considera un procesador vectorial que, comparado con el del
problema anterior, dispone de más cauces de acceso a memoria (dos más) de forma que,
la secuencia de instrucciones vectoriales se ejecuta en menos tiempo. Concretamente, se
indica que para vectores de 64 componentes (el tamaño de los registros vectoriales):

TCV=104 ciclos y TPC=1 ciclo

Por tanto, se puede estimar TLI de la expresión TCV=TLI+K*TPC, con K=64.

TLI = TCV – 64*TPC = 104 – 64*1 =40

En la Figura 5.5 se muestra una posible distribución temporal de las operaciones

vectoriales que justifica los valores de TCV, TLI y TPC para este caso.

6+1 12 64
12+1 7+1

TLI= (12+1)+(7+1)+(6+1)+12=40
TPC=1
Figura 5.5 Secuencia temporal de operaciones vectoriales (encadenamientos y
concurrencia)
Así pues, teniendo en cuenta que TBASE= 10 ciclos, TBUCLE=15, MVL=64, y usando la
expresión de Rn, para n=66:

 66 
T 66  T BASE    * ( T B U C L E  T L I )  6 6 * T P C  1 0  2 * ( 1 5  4 0 )  6 6 * 1  1 8 6 ciclos
 M VL

Para el cálculo de Rinf se utilizará la expresión de Tn para determinar Rn,

O p e r a c i o n e s .V e c t o r .* n * ( f r e c u e n c i a ( M H z ) ) 2 * n *80
Rn  (M FLO PS)  (M FLO PS)
 n   n 
(1 0    * (1 5  4 0 )  n * 1 )( c ic lo s ) 10  55*    n
64  64 
para aplicar el límite cuando n tiende a infinito se tienen en cuenta las cotas:

2 * n *80 2 * n *80
 Rn 
n n
10  (  1) * 5 5  n 10  ( )*55  n
64 64

por lo que, en el límite se tiene que

2 * n *80 160
R  lim R n  lim   8 6 .0 5 M F L O P S
in f
n  n  n 55
10  ( )*55  n 1
64 64

Comparado con el valor de Rinf obtenido en el problema anterior, se comprueba que se

ha incrementado el rendimiento a más del doble al aumentar el ancho de banda de la
conexión con la memoria (más cauces de acceso a memoria).

13 (Ejercicios de clase)
¿Cuál es el tiempo de ejecución, Tn, y el número e ciclos por resultado, CPR, para la
operación vectorial A=B*s, donde s es un escalar y los vectores tienen 200 componentes
(n=200)?

Suponga que:
- La máquina tiene registros vectoriales de 64 componentes
- TBASE=10, TBUCLE=15, y TPC=3
- Los tiempos de latencia de inicio son TLI(load/store)=12 ciclos,
TLI(multiplicación)=7 ciclos, TLI(encaminamiento unidad_de_datos/memoria o
viceversa)=4 ciclos.

Solución.
A continuación, en la Figura 5.1, se muestra el programa en DLXV, donde se considera
que los vectores A y B tienen sus direcciones de memoria cargadas inicialmente en los
registros Ra y Rb, y que el escalar s están en el registro Fs.

; Se carga en R2 la dirección del final de A

ADDI R2,R0,#1600 ;R0 = 0 siempre y 1600 = 200*8 (8 bytes por dato)
 ADD R2,R2,Ra ; R2 apunta al final del vector A

; R1 = 200 mod 64 (VL = k mod MVL)

ADDI R1,R0,#8 ; Resto de 200/64 es 8 (200 mod 64=8)
MOVI2S VLR,R1 ; VL=8 (la longitud del primer trozo de vector)
ADDI R1,R0,#64 ; R1=64 (8 componentes de 8 bytes en el primer trozo)
ADDI R3,R0,#64 ; Se carga la longitud de los otros trozos en R3

loop: LV V1,Rb ; Cargar en V1 el trozo correspondiente de B

MULTSV V2,Fs,V1 ; Multiplicación de s por el trozo correspondiente de B
SV Ra,V2 ; Se almacena el trozo obtenido a partir de la dirección Ra

; low = low + VL
ADD Ra,Ra,R1 ; Apuntar al siguiente trozo de A
ADD Rb,Rb,R1 ; Apuntar al siguiente trozo de B

; VL = MVL
ADDI R1,R0,#512 ; Cada trozo de vector tiene 64 elementos de 8 bytes (512)
MOVI2S VLR,R3 ; La longitud del vector es 64 (VL=64)

SUB R4,R2,Ra ; R4 = R2 – Ra
BNZ R4,loop ; Si R4 no es 0 hay que repetir el bucle
Figura 5.1 Código DLXV del cálculo de A=s*B

Teniendo en cuenta los datos del problema, n=200, MVL=64 (número de componentes
de los registros vectoriales), y se define

VL = n mod MVL = 200 mod 64 =8

La expresión correspondiente al modelo de prestaciones con troceado de vector es

 n 
Tn  T BASE   * (T BU CLE  T L I )  n * T P C
 M V L 

por lo que, sustituyendo los valores correspondientes se tiene que

200 
Tn  1 0    * ( 1 5  T L I )  2 0 0 * 3
 64

donde falta conocer el valor de TLI. Para estimarlo, tal y como muestra la Figura 5.2, se
tienen en cuenta los tiempos de latencia de los cauces de carga de memoria (LOAD) y
multiplicación, considerando además los ciclos necesarios para encaminar los datos
desde un cauce hasta el otro (4 ciclos, según el enunciado), y el almacenamiento final
(STORE)

TLI = 12 (LOAD) + 4 (LOAD-mult) + 7 (multiplicación) + 4 (mult-LOAD) + 12

(STORE)
La organización de los cauces que se muestra en la Figura 5.2 se deduce al considerar
que el valor de TPC es igual a 3 ciclos, y por lo tanto tienen que aparecer tres
secuencias de componentes no solapadas.

Es decir TLI=39 ciclos

Si se sustituye el valor de TLI en la expresión de TCV se tiene que TCV=826.

Por tanto, el número de ciclos por resultado es

Tn 8 2 6
C PR    4 .1 3
n 200

LOAD

12 n<64
4
7 STORE
mult 4
12

Figura 5.2 Distribución secuencial de cauces

14 (Ejercicios de clase)
En un procesador vectorial con registros vectoriales de 16 componentes, una sóla
unidad de carga/almacenamiento de memoria (LV/SV) y un único multiplicador, se
ejecuta el bucle

for i:=1 to 342 do Z(i):=a*Z(i)+b*X(i)

Teniendo en cuenta el tiempo de ejecución de la secuencia de instrucciones vectoriales

que implementan Z:=a*Z+b*X con 16 componentes:

- LV V1,Rz (Carga de V1 con datos a partir de la dirección Rz): Empieza en el

ciclo 0 y termina en el 23;
- LV V2,Rx (Carga de V2 con datos a partir de la dirección Rx): Empieza en el
ciclo 23 y termina en el 46;
- MULTSV V1,Ra,V1 (Multiplicación de a por el registro vectorial V1): Empieza
en el ciclo 8 y termina en el 34
- MULTSV V2,Rb,V2 (Multiplicación de b por el registro vectorial V2): Empieza
en el ciclo 34 y termina en el 60
- ADDV V3,V1,V2 (Suma vectorial de V1, y V2): Empieza en el ciclo 45 y
termina en el 68
- SV Rz,V3 (Almacenamiento de V3 a partir de la dirección almacenada en Rz):
Empieza en el ciclo 53 y termina en el 76

y considerando que TBASE =15 ciclos; y TBUCLE=10 ciclos; calcule para el bucle, los
valores del tiempo de ejecución, T342, y el valor de Rinf.. ¿Cuáles serían los valores
anteriores si se dispusiese de 2 multiplicadores y de 3 unidades de
carga/almacenamiento?

Nota: La frecuencia de reloj del procesador es de 500 M Hz y los tiempos de latencia

para los cauces vectoriales son TLI(ADDV)=7 ciclos; TLI(MULTSV)=10 ciclos;
TLI(LV)=7 ciclos, y TLI(SV)=7 ciclos.

Solución.
Teniendo en cuenta los datos de comienzo y final de cada instrucción que se dan en el
enunciado se puede construir el diagrama que se da a continuación:

7 23
...
7 46
...
10 34
...
10 60
...
7 68
...
... 7

A partir de este diagrama se puede determinar la latencia del cauce. Para ello, basta
considerar la barra en la parte inferior de la figura. Los tramos claros corresponden al
tiempo fijo asociado a las latencias individuales de algunos de los cauces. Los tramos
más oscuros tendrán longitudes que variarán en función del número de componentes.
Además, hay tres ciclos más que considerar, correspondientes a las discontinuidades en
la barra.

Por tanto, el tiempo de procesamiento para n componentes, siendo n<16 (tamaño de los
registros vectoriales) es:

T(n<16) = 7 + 1 + 10 + n + 10 + 1 + n + 7 + 1 + 7 = 44 + 2*n

y por tanto TLI=44 y TPC=2.

Utilizando las expresiones correspondientes se pueden determinar el valor de T342 y Rinf.

Así,

 342 
T 342  T BA SE    T B U C L E  T L I   3 4 2  T P C
 M V L 

y sustituyendo los valores correspondientes se tiene:

342 
T 342  1 5  
 16    1 0  4 4   3 4 2  2  1 9 0 9
y para Rinf se tendrá que:

3* n * f 3* n * (5 0 0 * 1 0 6 )
R in f  lim
n  T n ( c ic lo s)
 lim
n   n 
 2 7 9 .0 7 M F L O P S
15     ( 1 0  4 4 )  2  n
16

(b) Para el caso en el que se tienen 2 multiplicadores y 3 unidades de

carga/almacenamiento, el diagrama de ejecución de las instrucciones oara el caso de n
menor o igual a 16 se muestra a continuación. Como se observa en el diagrama, a partir
de la barra de la parte inferior se puede obtener que:

T(n<16) = 7 + 2 + 10 + 1 + 7 + 1 + n + 7 = 35 +n

por lo que TLI=35 ciclos, y n=1 ciclo.

7 23
...
7 24
...
10 34
...
10 35
...
7
...
... 7

Por lo tanto, utilizando las mismas expresiones que antes, se puede determinar T342 y
Rinf:

 342 
T 342  T BA SE    T B U C L E  T L I   3 4 2  T P C
 M V L 

342 
T 342  1 5  
 16    1 0  3 5   3 4 2  1  1 3 4 7

Con respecto a la situación anterior, se ha producido una reducción de casi un 30% en el

tiempo consumido.

3* n * f 3* n * (5 0 0 * 1 0 6 )
R in f  lim
n  T n ( c ic lo s)
 lim
n   n 
 3 9 3 .7 M F L O P S
15     ( 1 0  3 5 )  n
1 6

Se han incrementado los MFLOPS en un 29.12% (es decir, en casi un 30%).

15 (Examen septiembre 2007)

En un procesador vectorial, con una frecuencia de reloj de 500 MHz y con registros
vectoriales de 16 componentes, se ejecuta el siguiente bucle utilizando la técnica de
troceado del vector (strip mining).

for i := 1 to n do Z(i) := a*Z(i) + b*X(i) + c*Y(i)

Teniendo en cuenta que el tiempo de ejecución es TCV=63 ciclos para la secuencia de

instrucciones vectoriales que implementan Z := a*Z + b*X + c*Y con 16 componentes,
que el valor del tiempo de latencia de inicio es TLI=15 ciclos, que el tiempo
correspondiente a las operaciones escalares necesarias para preparar el ciclo es T BASE
=10 ciclos, y que el tiempo correspondiente al control del bucle en el troceado del
vector es TBUCLE=20 ciclos, calcule para el bucle:

(a) El tiempo de ejecución para n=317 elementos, T317.

(b) El número de operaciones ejecutadas por unidad de tiempo para un vector de

longitud infinita, Rinf.

Solución.
Sabemos que en un procesador vectorial, el tiempo para procesar una operación
completa vectorial (para los 16 elementos que caben en un registro vectorial) es:

TCV = TLI + MVL · TPC

Por lo tanto, podemos obtener el tiempo por componente de la secuencia de

instrucciones vectoriales como:

TCV  TLI 63  15
TPC   3
MVL 16

Una vez obtenido el tiempo por componente, el tiempo de ejecución del programa se
obtiene mediante la siguiente expresión:

 k 
Tk  TBASE     TLI  TBUCLE   k  TPC
 MVL 

Por tanto, el tiempo para procesar 317 elementos sería de:

 317 
T317  10    15  20  317  3  1661 ciclos  1661 6 segundos
 16  500  10

El rendimiento de un cauce vectorial se obtiene mediante la siguiente expresión:

 k  operacione
s vectorial
es 5k  500 106 25k  108
Rk   
Tk k k
10    15  20  3k 10 35   3k
16
   16

Por tanto, el máximo rendimiento se obtendrá cuando el tamaño del vector tienda a
infinito, es decir,

25  10 8
R  lim Rk   481.93 MFLOPS
k  35
3
16

16 (Examen febrero 2007)

Considere que el siguiente bucle:

for i=1 to N do X[i] = a*Y[i]; X[i], Y[i] y a son números en coma flotante

Se ejecuta en un procesador vectorial de 32 bits que dispone de una única unidad para
acceder a los datos de memoria. Los tiempos de latencia de inicio para los cauces son
TLI(LV)=5 ciclos, TLI(MULTSV)=10 ciclos, y TLI(SV)=5 ciclos, y los registros
vectoriales tienen 64 componentes (MVL=64). Se tiene que T BASE=15 ciclos, TBUCLE=10
ciclos, y la frecuencia del procesador es igual a 1 GHz

(a) ¿Cuál es el valor de R∞?

(b) Si el array que se multiplica por el escalar tiene N=1024 elementos, ¿Cuánto
tarda en ejecutarse?

Solución.
Dado que el tamaño de los registros vectoriales del procesador propuesto en el problema
es MVL = 64 y que el vector que deseamos procesar tiene un tamaño N que no está
definido, tendremos que aplicar la técnica de strip-mining para trocear el vector y
procesarlo iterativamente. El compilador realizará un cambio al código similar a este:

low = 1;
VL = (n mod MVL); /* resto de la division */
for ( j = 0 ; j <= (n / MVL) ; j++)
{
for ( i = low ; i < low + VL ; i++)
X(i):= a*Y(i);
low += VL;
VL = MVL;
}

Al traducir este código a ensamblador, el bucle que se encuentra sombreado se cambiará

por instrucciones vectoriales y el resto de instrucciones permanecerán tal y como están.

Dado que R∞ se define como

k  operaciones vectoriales  frecuencia

R  lim Rk  lim
k  k  Tk
el primer paso consistirá en estimar el tiempo Tk. Para ello, debemos determinar las
instrucciones vectoriales que se ejecutarán dentro del bucle interno y la forma en que se
solaparán y encadenarán. Dichas instrucciones serán la carga vectorial de Y, una
multiplicación, y un almacenamiento del resultado en X. El diagrama de tiempos de
estas instrucciones es el siguiente:
5 LV VY, RY

10 MULTSV VX, a, VY

5 SV RX, VX

5 64 64 5

Como sólo tenemos una unidad de carga/almacenamiento, la instrucción SV debe

esperar a que termine la instrucción LV, por tanto, tenemos que el tiempo por
componente es TPC = 2 y que el tiempo de latencia inicial TLI = 5 + 5 = 10, ya que la
multiplicación ha quedado solapada con las instrucciones de carga y de
almacenamiento. Con estos valores de TLI y TPC y con los valores de TBASE y TBUCLE
que nos dan en el enunciado del problema, podemos calcular Tk como:

 k 
Tk  TBASE     TLI  TBUCLE   k  TPC  15   k 10  10  2·k ciclos
 MLV   64 

Una vez obtenido Tk, obtenemos R∞:

k  ops vec  frecuencia k  11000

R  lim Rk  lim  lim  432,43 MFLOPS
Tk k 
15    10  10   2·k
k  k  k 

 64 

El tiempo de ejecución en el procesador vectorial es de:

1024 
T1024  15   10  10  2 1024  2383 ns
 64 

17 (Examen febrero 2004)

En un procesador vectorial a 500 MHz, con registros vectoriales de 32 componentes,
tres unidades de carga/almacenamiento de memoria (LV/SV), un único sumador, y un
único multiplicador, se ejecuta el bucle:

for i:=1 to 342 do Z(i):=a*Z(i)+X[i]

Determine el valor de R teniendo en cuenta que el procesador puede encadenar y

solapar los cauces y que cada uno de esos cauces puede terminar un componente por
ciclo.

(Nota: TLI(Mult) =16 ciclos; TLI(Suma)=8 ciclos; TLI(LV/SV)=8; TBASE=8 ciclos;

TBUCLE=10 ciclos).

Solución.
Dado que el tamaño de los registros vectoriales del procesador propuesto en el problema
es MVL = 32 y que el vector que deseamos procesar tiene un tamaño n = 342 mayor,
tendremos que aplicar la técnica de strip-mining para trocear el vector y procesarlo
iterativamente. El compilador realizará un cambio al código similar a este:

low = 1;
VL = (n mod MVL); /* resto de la division */
for ( j = 0 ; j <= (n / MVL) ; j++)
{
for ( i = low ; i < low + VL ; i++)
Z(i) = a*Z(i) + X(i);
low += VL;
VL = MVL;
}

Al traducir este código a ensamblador, el bucle que se encuentra sombreado se cambiará

por instrucciones vectoriales y el resto de instrucciones permanecerán tal y como están.

Dado que R∞ se define como

k  operaciones vectoriales  frecuencia

R  lim Rk  lim
k  k  Tk

el primer paso consistirá en estimar el tiempo Tk. Teniendo en cuenta las latencias
iniciales del enunciado y la existencia de tres unidades de carga/almacenamiento, un
sumador y un multiplicador, el diagrama de tiempos de estas tres instrucciones es el
siguiente:

TLI = 8 LV V1, Rz

TLI = 8 LV V2, Rx

TLI = 16 MULTVS V3, V1, Fa

TLI = 8 ADDVS V4, V2, V3

TLI = 8 SV V4, Rz

Por lo que el tiempo de latencia inicial de la secuencia es de 8 + 16 + 8 + 8 = 40 ciclos,

ya que las tres operaciones de acceso a memoria se pueden solapar porque hay tres
unidades de LV/SV. El el tiempo por componente es TPC = 1 ciclo porque hemos
podido encadenar las operaciones vectoriales. Con estos valores de TLI y TPC y con los
valores de TBASE y TBUCLE que nos dan en el enunciado del problema, podemos calcular
Tk como:

 k 
Tk  TBASE     TLI  TBUCLE   k  TPC  8   k  40  10  k cilos
 MLV   32 

Una vez obtenido Tk, obtenemos R∞:

k  ops vec  frecuencia k  2  500 1000k

R  lim Rk  lim  lim  lim  390,244 MFLO
k  k  Tk k   
k   k 
8     40  10  k 8     50  k
k

 32   32 
18 (Examen septiembre 2004)
En un procesador vectorial a 1 GHz, con registros vectoriales de 64 componentes, tres
unidades de carga/almacenamiento de memoria (LV/SV), un sumador y un
multiplicador, se ejecuta el bucle:

for i:=1 to 342 do Z(i):= Z(i)+X(i)*Y(i)

Determine el valor de R teniendo en cuenta que el procesador puede encadenar y

solapar los cauces y que cada uno de esos cauces, por separado, puede terminar un
componente por ciclo.
(Nota: TLI(Mult) = 16 ciclos; TLI(Suma) = 8 ciclos; TLI(LV/SV) = 8 ciclos; T BASE = 8
ciclos; TBUCLE = 10 ciclos).

Solución.
Dado que el tamaño de los registros vectoriales del procesador propuesto en el problema
es MVL = 64 y que el vector que deseamos procesar tiene un tamaño n = 342 mayor,
tendremos que aplicar la técnica de strip-mining para trocear el vector y procesarlo
iterativamente. El compilador realizará un cambio al código similar a este:

low = 1;
VL = (n mod MVL); /* resto de la division */
for ( j = 0 ; j <= (n / MVL) ; j++)
{
for ( i = low ; i < low + VL ; i++)
Z(i):= Z(i)+X(i)*Y(i);
low += VL;
VL = MVL;
}

Al traducir este código a ensamblador, el bucle que se encuentra sombreado se cambiará

por instrucciones vectoriales y el resto de instrucciones permanecerán tal y como están.

Dado que R∞ se define como

k  operaciones vectoriales  frecuencia

R  lim Rk  lim
k  k  Tk

el primer paso consistirá en estimar el tiempo Tk. Para ello, debemos determinar las
instrucciones vectoriales que se ejecutarán dentro del bucle interno y la forma en que se
solaparán y encadenarán. Dichas instrucciones serán tres cargas vectoriales de X, Y, y Z,
una multiplicación, una suma y un almacenamiento del resultado en Z. El diagrama de
tiempos de estas instrucciones es el siguiente:
TLI=8 LV VX, RX

TLI=8 LV VY, RY

TLI=8 LV VZ, RZ

TLI=16 MULT V1, VX, VY

TLI=8 ADD VZ, VZ, V1

TLI=8 SV RZ, VZ

8 64 64 8

Como sólo tenemos tres unidades de carga/almacenamiento, la instrucción SV debe

esperar a que terminen las instrucciones LV, por tanto, tenemos que el tiempo por
componente es TPC = 2 y que el tiempo de latencia inicial TLI = 8 + 8 = 16, ya que la
multiplicación y la suma han quedado solapadas con las instrucciones de carga y de
almacenamiento. Con estos valores de TLI y TPC y con los valores de TBASE y TBUCLE
que nos dan en el enunciado del problema, podemos calcular Tk como:

 k 
Tk  TBASE     TLI  TBUCLE   k  TPC  8   k 16  10  2·k ciclos
 MLV   64 

Una vez obtenido Tk, obtenemos R∞:

k  ops vec  frecuencia k  2  1000 2000k

R  lim Rk  lim  lim  lim  831,17 M
k  k  Tk k  k    k 
8   16  10  2·k 8     26   2·k
k

 64   64 

19 (Examen febrero 2005)

En un procesador vectorial a 1 GHz, con registros vectoriales de 32 componentes, tres
unidades de carga/almacenamiento de memoria (LV/SV), un sumador y un
multiplicador segmentados, se ejecuta el bucle:

for i:=1 to 350 do Z(i):=Z(i)+X[i]*Y[i]

Determine el valor de R teniendo en cuenta que el procesador puede encadenar y

solapar los cauces y que cada uno de esos cauces, por separado, puede terminar un
componente por ciclo.
(Nota: TLI(Mult) =16 ciclos; TLI(Suma)=8 ciclos; TLI(LV/SV)=8; TBASE=8 ciclos;
TBUCLE=10 ciclos).

Solución.
Dado que el tamaño de los registros vectoriales del procesador propuesto en el problema
es MVL = 32 y que el vector que deseamos procesar tiene un tamaño n = 350 mayor,
tendremos que aplicar la técnica de strip-mining para trocear el vector y procesarlo
iterativamente. El compilador realizará un cambio al código similar a este:
 low = 1;
VL = (n mod MVL); /* resto de la division */
for ( j = 0 ; j <= (n / MVL) ; j++)
{
for ( i = low ; i < low + VL ; i++)
Z(i):= Z(i)+X(i)*Y(i);
low += VL;
VL = MVL;
}

Al traducir este código a ensamblador, el bucle que se encuentra sombreado se cambiará

por instrucciones vectoriales y el resto de instrucciones permanecerán tal y como están.

Dado que R∞ se define como

k  operaciones vectoriales  frecuencia

R  lim Rk  lim
k  k  Tk

el primer paso consistirá en estimar el tiempo Tk. Para ello, debemos determinar las
instrucciones vectoriales que se ejecutarán dentro del bucle interno y la forma en que se
solaparán y encadenarán. Dichas instrucciones serán tres cargas vectoriales de X, Y, y Z,
una multiplicación, una suma y un almacenamiento del resultado en Z. El diagrama de
tiempos de estas instrucciones es el siguiente:
TLI=8 LV VX, RX

TLI=8 LV VY, RY

TLI=8 LV VZ, RZ

TLI=16 MULT V1, VX, VY

TLI=8 ADD VZ, VZ, V1

TLI=8 SV RZ, VZ

8 32 32 8

Como sólo tenemos tres unidades de carga/almacenamiento, la instrucción SV debe

esperar a que terminen las instrucciones LV, por tanto, tenemos que el tiempo por
componente es TPC = 2 y que el tiempo de latencia inicial TLI = 8 + 8 = 16, ya que la
multiplicación y la suma han quedado solapadas con las instrucciones de carga y de
almacenamiento. Con estos valores de TLI y TPC y con los valores de TBASE y TBUCLE
que nos dan en el enunciado del problema, podemos calcular Tk como:

 k 
Tk  TBASE     TLI  TBUCLE   k  TPC  8   k 16  10  2·k ciclos
 MLV   32 

Una vez obtenido Tk, obtenemos R∞:

k  ops vec  frecuencia k  2  1000 2000k

R  lim Rk  lim  lim  lim  711,11 M
k  k  Tk k   
k    
k
8    16  10   2·k 8     26   2·k
k

 32   32 
20 (Examen diciembre 2007)
En un procesador vectorial a 1 GHz, con registros vectoriales de 16 componentes, tres
unidades de carga/almacenamiento de memoria (LV/SV), un sumador y un
multiplicador, se ejecuta el bucle:

for i:=1 to 500 do Z(i):= Z(i)+X(i)*Y(i)

Determine el valor de R teniendo en cuenta que el procesador puede encadenar y

solapar los cauces y que cada uno de esos cauces, por separado, puede terminar un
componente por ciclo.
(Nota: TLI(Mult) = 20 ciclos; TLI(Suma) = 15 ciclos; TLI(LV/SV) = 25 ciclos; T BASE =
8 ciclos; TBUCLE = 10 ciclos).

Solución.
El primer paso para calcular el rendimiento del procesador para el programa del
enunciado consiste en obtener el tiempo de latencia de inicio (TLI) y el tiempo que se
invierte por componente (TPC). Para ello nos ayudaremos del siguiente diagrama de
tiempos:

TLI=25 LV VX, RX

TLI=25 LV VY, RY

TLI=25 LV VZ, RZ

TLI=20 MULT V1, VX, VY

TLI=15 ADD VZ, VZ, V1

TLI=25 SV RZ, VZ

25 20 15 25 16

Teniendo en cuenta este diagrama, el programa tiene un TLI = 25 + 20 + 15 + 25 = 85 y

un TPC = 1. Con estos valores y con los valores de TBASE y TBUCLE que nos dan en el
enunciado del problema, podemos calcular Tk como:

 k 
Tk  TBASE     TLI  TBUCLE   k  TPC  8   k   85  10  1·k ciclos
 MLV  16 

Una vez obtenido Tk, obtenemos R∞:

k  ops vec  frecuencia k  2  1000 2000 k

R  lim Rk  lim  lim  lim  288,288 MF
k  k  Tk k  k    k 
8     85  10   1  k 8     95  k
k

16  16 

21 (Examen septiembre 2005)

En un procesador vectorial a 1 GHz, con registros vectoriales de 32 componentes, tres
unidades de carga/almacenamiento de memoria (LV/SV), un sumador, y un
multiplicador, se ejecuta el bucle:

for i:=1 to 512 do Z(i):=Z(i)+X[i]*Y[i]

Determine el valor de R teniendo en cuenta que el procesador puede encadenar y
solapar los cauces y que cada uno de esos cauces, por separado, puede terminar un
componente por ciclo. ¿Qué ocurriría si los registros vectoriales fuesen de 64
componentes?

Nota: TLI(Mult) = 24 ciclos; TLI(Suma) = 12 ciclos; TLI(LV/SV) = 8; T BASE = 8 ciclos;

TBUCLE = 10 ciclos.

Solución.
El tamaño de los registros vectoriales del procesador propuesto en el problema es MVL
= 32, que es bastante menor que el vector que deseamos procesar, que tiene un tamaño
n = 512 elementos. Por tanto, tendremos que aplicar la técnica de strip-mining para
trocear el vector y procesarlo iterativamente. Dado que R∞ se define como

k  operaciones vectoriales  frecuencia

R  lim Rk  lim
k  k  Tk

el primer paso consistirá en estimar el tiempo Tk. Para ello, debemos determinar las
instrucciones vectoriales que se ejecutarán dentro del bucle interno y la forma en que se
solaparán y encadenarán. Dichas instrucciones serán tres cargas vectoriales de X, Y, y Z,
una multiplicación, una suma y un almacenamiento del resultado en Z. El diagrama de
tiempos de estas instrucciones es el siguiente:

TLI=8 LV VX, RX

TLI=8 LV VY, RY

TLI=8 LV VZ, RZ

TLI=24 MULT V1, VX, VY

TLI=12 ADD VZ, VZ, V1

TLI=8 SV RZ, VZ

44 32 8

Las latencias de la multiplicación y de la suma se solapan completamente con las cargas

vectoriales, por lo que en cuanto se produce el primer resultado, como ya han terminado
las tres unidades LV/SV, ya puede empezar a almacenarse. Por tanto, tenemos que el
tiempo por componente es TPC = 1 y que el tiempo de latencia inicial TLI = 8 + 24 + 12
+ 8 = 52. Con estos valores de TLI y TPC y con los valores de TBASE y TBUCLE que nos
dan en el enunciado del problema, podemos calcular Tk como:

 k 
Tk  TBASE    TLI  TBUCLE   k  TPC  8   k   52  10  1·k ciclos
 MLV   32 

Una vez obtenido Tk, obtenemos R∞:

k  ops vec  frecuencia k  2  1000 2000k

R  lim Rk  lim  lim  lim  680,85 MFL
k  k  Tk k  k   k 
8     52  10  1  k 8     62  k
k

 32   32 
Si MLV = 64 TLI y TPC cambian, como se muestra en el siguiente diagrama.
TLI=8 LV VX, RX

TLI=8 LV VY, RY

TLI=8 LV VZ, RZ

TLI=24 MULT V1, VX, VY

TLI=12 ADD VZ, VZ, V1

TLI=8 SV RZ, VZ

8 64 64 8

En este caso, TLI = 8 + 8 = 16 y TPC = 2, ya que el SV debe esperar a los LV (sólo hay
tres unidades LV/SV). Con estos valores de TLI y TPC, obtenemos R∞:

k  ops vec frecuencia k  2  1000 2000k

R  lim Rk  lim  lim  lim  831,17 M
k  k  Tk k  k    k 
8    16  10  2  k 8     26  2k
k

 64   64 

22 (Examen diciembre 2005)

Suponga la secuencia de instrucciones vectoriales en un procesador vectorial de 32 bits:

(1) lv v1, r1 ; Cargar en V1 a partir de la dirección contenida en R1

(2) lv v2, r2 ; Cargar en V2 a partir de la dirección contenida en R2
(3) multsv v3, f0, v1 ; V3 = F0 * V1 (F0 es un escalar)
(4) addv v4, v3 ,v2 ; V4 = V3 + V2
(5) sv v4, r3 ; Almacenar V4 a partir de la dirección en R3

Se dispone de dos cauces para acceder a los datos de memoria, pero las instrucciones de
carga LV no se encadenan (debe terminar completamente una para poder iniciar la
siguiente) ni entre ellas, ni con las demás. Las restantes instrucciones (MULTSV,
ADDV, SV) pueden encadenar sus cauces, los tiempos de latencia de inicio para los
cauces son TLI(LV) = 6 ciclos, TLI(MULTSV) = 9 ciclos, TLI(ADDV) = 5 ciclos, y
TLI(SV) = 6 ciclos, y los registros vectoriales tienen 64 componentes (MVL = 64). (a)
¿Cuál es el valor de Rinf suponiendo que TBASE = 15 ciclos, TBUCLE = 10 ciclos, y la
frecuencia del procesador es igual a 500 MHz?; (b) ¿Cuál sería el código escalar cor
arquitectura LOAD/STORE que implemente la secuencia de instrucciones vectoriales
anteriores? (c) Si ese código escalar se ejecuta en un procesador superescalar de 32 bits
a 500 MHz que consigue terminar un promedio de 2 instrucciones por ciclo en dicha
ejecución ¿es mejor utilizar el procesador superescalar que el vectorial para algún
tamaño del problema?

Solución.
El primer paso para calcular el rendimiento del procesador para el programa del
enunciado consiste en obtener el tiempo de latencia de inicio (TLI) y el tiempo que se
invierte por componente (TPC). Para ello nos ayudaremos del siguiente diagrama de
tiempos:
 6 LV V1, R1

6 LV V2, R2

9 MULTSV V3, F0, V1

5 ADDV V4, V3, V2

6 SV V4, R3

6 64 9+5+6 64

En el diagrama se muestra cómo las operaciones de carga no se pueden encadenar con

ninguna otra ni entre sí, pero sí que se pueden solapar porque existen dos unidades de
carga en la máquina. Por tanto, el programa tiene un TLI = 6 + 9 + 5 + 6 = 26 y un
TPC = 2. Con estos valores y con los valores de TBASE y TBUCLE que nos dan en el
enunciado del problema, podemos calcular Tk como:

 k 
Tk  TBASE     TLI  TBUCLE   k  TPC  15   k  26  10  2·k ciclos
 MLV   64 

Una vez obtenido Tk, obtenemos R∞:

k  ops vec  frecuencia k  2  500 1000k

R  lim Rk  lim  lim  lim  390,24
k  k  Tk k  k  k  k 
15     26  10  2  k 15     36  2  k
 64   64 

Asumiendo que los vectores están almacenados en las posiciones de memoria

etiquetadas con X, Y y Z, y que el tamaño del vector está en la posición de memoria
etiquetada con MVL, el código escalar para implementar las instrucciones vectoriales
anteriores es:

addd r1, r0, r0 ; r1 = 0 (Contador del bucle)

lw r2, MVL(r0) ; r2 = Tamaño del vector (en elementos)
slli r2, r2, #2 ; r2 = r2 * 4 (Tamaño del vector em bytes)
(1) inicio: ld f2, X(r1) ; f2 contendrá los datos del primer vector
(2) ld f4, Y(r1) ; f4 contendrá los datos del segundo vector
(3) multd f6, f0, f2 ; Multiplico por el escalar en f0
(4) addd f8, f6, f4 ; Sumo con el otro vector
(5) sd f8, Z(r1) ; Almaceno el resultado
(6) addi r1, r1, #4 ; Incremento el contador
(7) seq r3, r1, r2 ; Compruebo si he llegado al final del vector
(8) beqz r3, inicio ; Salto a por el siguiente dato

Contando sólo las instrucciones del cuerpo del bucle, se ejecutarían

8 × MVL = 8 × 64 = 512 instrucciones. Como no se nos dice nada sobre el número de
unidades funcionales o su latencia, asumimos que no habrá riesgos en la ejecución y que
se retirarán 2 instrucciones por ciclo, con lo que el programa tardaría para un vector de
tamaño k:

Tk'   8  k  /2 ciclos
Para ver si el uso de un procesador superescalar mejora al vectorial para algún tamaño
de vector sólo habría que comprobar si existe algún valor de k tal que Tk > Tk’. Como los
dos procesadores funcionan a una frecuencia de reloj de 500 MHz, podemos hacer la
comparativa en términos de ciclos, ya que el tiempo de ciclo de las dos máquinas es el
mismo. Por tanto, habría que ver para qué valores de k se cumple esta inecuación:

k  k 
15  36    2k  8k / 2  15  36   2k
 64   64 

Si 1 ≤ k ≤ 64, tenemos que 15 + 36 > 2k, o lo que es lo mismo, que k < 25.5.

Si 65 ≤ k ≤ 128, tenemos que 15 + 2·36 > 2k. Al resolver esta inecuación, tenemos que
k debería ser menor que 43.5, que está fuera del intervalo que habíamos supuesto. Esta
contradicción ocurre para también para valores más altos de k, por lo que podemos
concluir que para este programa concreto y con las dos arquitecturas del enunciado, se
mejorarían las prestaciones con el procesador superescalar solamente para vectores de
hasta 25 elementos. Para vectores mayores interesa más usar la arquitectura vectorial.

23 (Examen febrero 2006)

Suponga la secuencia de instrucciones vectoriales en un procesador vectorial de 32 bits:
(1) LV V1, R1 ; Cargar en V1 a partir de la dirección contenida en R1
(2) LV V2, R2 ; Cargar en V2 a partir de la dirección contenida en R2
(3) MULTSV V3, F0, V1 ; V3 = F0*V1 (F0 es un escalar)
(4) ADDV V4, V3, V2 ; V4 = V3 + V2
(5) SV V4, R3 ; Almacenar V4 a partir de la dirección en R3

Se dispone de un único bus para acceder a los datos de memoria, y las instrucciones de
carga LV no se encadenan (debe terminar completamente una para poder iniciar la
siguiente) ni entre ellas, ni con las de almacenamiento SV. Los tiempos de latencia de
inicio para los cauces son TLI(LV)=5 ciclos, TLI(MULTSV)=10 ciclos, TLI(ADDV)=5
ciclos, y TLI(SV)=5 ciclos, y los registros vectoriales tienen 64 componentes
(MVL=64). (a) ¿Cuál es el valor de Rinf suponiendo que TBASE=15 ciclos, TBUCLE=10
ciclos, y la frecuencia del procesador es igual a 1 GHz?; (b) ¿Cuál sería el código
escalar para una arquitectura LOAD/STORE que implemente la secuencia de
instrucciones vectoriales anteriores? (c) Si ese código escalar se ejecuta en un
procesador superescalar de 32 bits a 1 GHz que consigue terminar un promedio de 2
instrucciones por ciclo en dicha ejecución ¿es mejor utilizar el procesador superescalar
que el vectorial para algún tamaño del problema?

Solución.
El diagrama de tiempos de la ejecución del código vectorial, teniendo en cuenta las
restricciones del enunciado, es el siguiente:
5 LV V1, R1

5 LV V2, R2

10 MULTSV V3, F0, V1

5 ADDV V4, V3, V2

5 SV V4, R3

5 64 5 64 5 64
Al disponer tan solo de una unidad de acceso a memoria, se deben secuenciar las tres
operaciones de acceso a memoria, lo que nos causa un TPC = 3 ciclos y un TLI = 3·5 =
15 ciclos. Las instrucciones de multiplicación y suma se pueden solapar con las tres
operaciones de acceso a memoria. Con estos valores y con los valores de TBASE y TBUCLE
que nos dan en el enunciado del problema, podemos calcular Tk como:

 k 
Tk  TBASE     TLI  TBUCLE   k  TPC  15   k 15  10  3·k ciclos
 MLV   64 

Una vez obtenido Tk, obtenemos R∞:

k  ops vec  frecuencia k  2  1000 2000k

R  lim Rk  lim  lim  lim  589,86
k  k  Tk k  k    k 
15   15  10  3  k 15     25  3  k
k

 64   64 

Asumiendo que los vectores están almacenados en las posiciones de memoria

etiquetadas con X, Y y Z, y que el tamaño del vector está en la posición de memoria
etiquetada con k, el código escalar para implementar las instrucciones vectoriales
anteriores es:

addd r1, r0, r0 ; r1 = 0 (Contador del bucle)

lw r2, k ; r2 = Tamaño del vector (en elementos)
slli r2, r2, #3 ; r2 = r2 * 8 (Tamaño del vector en bytes.
; Un double ocupa 8 bytes)
(1) inicio: ld f2, X(r1) ; f2 contendrá los datos del primer vector
(2) ld f4, Y(r1) ; f4 contendrá los datos del segundo vector
(3) multd f6, f0, f2 ; Multiplico por el escalar en f0
(4) addd f8, f6, f4 ; Sumo con el otro vector
(5) sd f8, Z(r1) ; Almaceno el resultado
(6) addi r1, r1, #8 ; Incremento el contador
(7) seq r3, r1, r2 ; Compruebo si he llegado al final del vector
(8) beqz r3, inicio ; Salto a por el siguiente dato

Contando sólo las instrucciones del cuerpo del bucle, se ejecutarían 8 × k instrucciones.
Como no se nos dice nada sobre el número de unidades funcionales o su latencia,
asumimos que no habrá riesgos en la ejecución y que se retirarán 2 instrucciones por
ciclo, con lo que el programa tardaría para un vector de tamaño k:

Tk'   8  k  /2 ciclos

Para ver si el uso de un procesador superescalar mejora al vectorial para algún tamaño
de vector sólo habría que comprobar si existe algún valor de k tal que Tk > Tk’. Como los
dos procesadores funcionan a una frecuencia de reloj de 1 GHz, podemos hacer la
comparativa en términos de ciclos, ya que el tiempo de ciclo de las dos máquinas es el
mismo. Por tanto, habría que ver para qué valores de k se cumple esta inecuación:

k  k 
15  25   3k  8k / 2  15  25   k
 64   64 
Si 1 ≤ k ≤ 64, tenemos que 15 + 25 = 40 > k.

Si 65 ≤ k ≤ 128, tenemos que 15 + 2·25 = 65 > k. Al resolver esta inecuación, tenemos

que k tiene que ser menor que 65 cuando habíamos supuesto que debería ser mayor o
igual 65. Es decir, que no hay ningún valor de k dentro de este intervalo que haga que el
procesador superescalar sea más rápido que el vectorial. Esta contradicción ocurre para
también para valores más altos de k, por lo que podemos concluir que para este
programa concreto y con las dos arquitecturas del enunciado, se mejorarían las
prestaciones con el procesador superescalar solamente para vectores de hasta 40
elementos. Para vectores mayores interesa más usar la arquitectura vectorial.

24 (Examen febrero 2008)

Se dispone de un procesador vectorial de 32 bits, con registros vectoriales de 64
elementos, que funciona a 750 MHz. El procesador dispone de tres cauces vectoriales,
uno de acceso a memoria, otro para sumar y restar vectores, y otro para multiplicarlos,
que se pueden encadenar entre sí, y ejecutar operaciones concurrentemente si lo
permiten las dependencias entre sus operandos.

Se desea ejecutar el siguiente fragmento de código en el procesador:

lv v1, A(r0) ; v1 <- A

lv v2, B(r0) ; v2 <- B
multsv v3, f0, v1 ; v3 = f0*v1
addv v4, v3, v2 ; v4 = v3 + v2
sv C(r0), v4 ; C <- v4

a) ¿Cuál es el valor de Rinf suponiendo que TBASE=15 ciclos y TBUCLE=10 ciclos?

b) ¿Y si se dispusiera de tres cauces de acceso a memoria?
c) ¿Cuál sería el código escalar (para la arquitectura DLX) que implemente la
secuencia de instrucciones vectoriales anteriores?
d) Si ese código escalar se ejecuta en un procesador superescalar de 32 bits a 1 GHz
que consigue terminar un promedio de 2 instrucciones por ciclo en dicha ejecución,
¿es mejor utilizar el procesador superescalar que el vectorial para algún tamaño del
problema?

NOTAS: Los tiempos de latencia de inicio para los cauces son TLI(LV)=8 ciclos,
TLI(MULTSV)=9 ciclos, TLI(ADDV)=5 ciclos, y TLI(SV)=8 ciclos.

Solución.
Para poder calcular Rinf es necesario calcular primero los valores de TLI y TPC para el
programa del enunciado. Para ello es muy útil el siguiente diagrama, en el que se
muestra la temporización de la ejecución de cada una de sus instrucciones:
 8 lv v1, A(r0)

8 lv v2, B(r0)

9 multsv v3, f0, v1

5 addv v4, v3, v2

8 sv C(r0), v4

8 64 8 64 8 64

Como solamente se dispone de un cauce de acceso a memoria y hay tres operaciones

que lo tienen que utilizar, se provoca un riesgo estructural que hace que el TPC sea 3. El
TLI es la suma de las latencias de las tres operaciones de acceso a memoria (8 + 8 + 8 =
24). Las operaciones aritméticas se pueden solapar con las de acceso a memoria, por lo
que no influyen en el cálculo del TLI y el TPC.

El tiempo de ejecución del código vectorial para vectores de k elementos sería:

 k 
Tk  TBASE     TLI  TBUCLE   k  TPC  15   k  24  10  3·k ciclos
 MLV   64 

Y la productividad del cauce:

Rk 

k  operaciones vectoriales  frecuencia k  2  750  106


Tk k 
15  34   3·k
 64 

Por lo que Rinf vale:

R  lim Rk  424,779 MFLOPS

k 

Si dispusiéramos de tres unidades de acceso a memoria, se podría evitar el cuello de

botella que se produce en la configuración anterior, tal y como muestra el siguiente
diagrama:
8 lv v1, A(r0)

8 lv v2, B(r0)

9 multsv v3, f0, v1

5 addv v4, v3, v2

8 sv C(r0), v4

8 9 5 8 64

En este caso, TPC = 1 y TLI = 8 + 9 + 5 + 8 = 30, así que rehaciendo las cuentas
tenemos que:

 k 
Tk  TBASE     TLI  TBUCLE   k  TPC  15   k   30  10  1·k ciclos
 MLV   64 
Y la productividad del cauce:

Rk 

k  operaciones vectoriales  frecuencia k  2  750  10 6


Tk k 
15  40   k
 64 

Por lo que Rinf vale:

R  lim Rk  923,077 MFLOPS

k 

Si el programa anterior tuviera que ejecutarse en un procesador superescalar, el código

podría ser el siguiente:

add r1, r0, r0 ; desplazamiento del primer elemento

ld r2, k ; número de elementos
bucle: lf f1, a(r1) ; f1 = a(i)
lf f2, b(r1) ; f1 = a(i)
multf f3, f1, f0 ; f3 = a(i)*f0
addf f3, f2, f3 ; f3 = a(i)*f0 + b(i)
sf c(r1), f3 ; c(i) = a(i)*f0 + b(i)
addi r1, r1, #4 ; desplazamiento del siguiente elemento
subi r2, r2, #1 ; queda un elemento menos
bnez r2, bucle ; vamos a por el siguiente

El tiempo de ejecución en un procesador superescalar de 1 GHz capaz de finalizar 2

instrucciones por ciclo sería:

1  1 
Tks  NI  CLI  Treloj   8k  2      9    4k  1  10 9 s
 2   10 

El tiempo del procesador vectorial del enunciado es:

k 
15  34   3k
k   64   k  
Tkv  15  34   3k ciclos  s   20  45,3   4k   10 -9 s
 64  750  10 6
  64  

Para saber si hay algún tamaño del problema tal que el procesador superescalar sea
mejor que el vectorial, hay que encontrar un valor de k tal que Tk  Tk , es decir, hay
s v

que resolver la siguiente inecuación para algún valor de k:

 k 
4k  1  20  45,3   4k
 64 
O lo que es lo mismo:
 k 
 19  45,3 
 64 

que es cierto para cualquier valor de k, lo que implica que el procesador superescalar es
mejor que el vectorial para cualquier tamaño de problema.
25 (Examen febrero 2004)
En un procesador vectorial a 500 MHz, con registros vectoriales de 16 componentes,
una única unidad de carga/almacenamiento de memoria (LV/SV) y un único
multiplicador, se ejecuta el bucle:

for i:=1 to 342 do if (i mod 2 = =0) Z(i):=a*Z(i)

Determine el valor de R teniendo en cuenta que el procesador puede encadenar los

cauces y que la memoria es entrelazada de orden inferior con 16 módulos y la primera
componente del vector Z está en la dirección de memoria ACB0h.

(Nota: TLI(Mult) =16 ciclos; TBASE=8 ciclos; TBUCLE=10 ciclos; y la memoria es de tipo
S y está ajustada de forma que el tiempo de acceso T a=M*t, donde M es el número de
módulos y t el tiempo de ciclo del procesador).

Solución.
Dado que el tamaño de los registros vectoriales del procesador propuesto en el problema
es MVL = 16 y que el vector que deseamos procesar tiene un tamaño n = 342 mayor,
tendremos que aplicar la técnica de strip-mining para trocear el vector y procesarlo
iterativamente. El compilador realizará un cambio al código similar a este:

low = 1;
VL = (n mod MVL); /* resto de la division */
for ( j = 0 ; j <= (n / MVL) ; j++)
{
for ( i = low ; i < low + VL ; i++)
if (i mod 2 == 0) then Z(i) = a*Z(i);
low += VL;
VL = MVL;
}

Al traducir este código a ensamblador, el bucle que se encuentra sombreado se cambiará

por instrucciones vectoriales y el resto de instrucciones permanecerán tal y como están.

Dado que R∞ se define como

operaciones en punto flotante  frecuencia

R  lim Rk  lim
k  k  Tk

el primer paso consistirá en estimar el tiempo Tk. Para ello hay que tener presente que
no se opera sobre todos los componentes del vector Z, sino solo sobre los componentes
pares del mismo. Para tratar esta situación podemos hacer uso del registro de máscara
VM fijándolo al valor (0101010101010101), de forma que solo se operará con los datos
situados en las posiciones pares de los registros vectoriales y los datos en las posiciones
impares permanecerán inalterados. Una vez inicializado el vector de máscara, el cuerpo
del bucle interno se reduce a una carga vectorial, una multiplicación y un
almacenamiento vectorial.

Además, como el sistema de memoria es de tipo S con entrelazado inferior, con 16

módulos y Ta = 16t, tras un tiempo de acceso de 16 ciclos nos irá proporcionando una
componente del vector consecutiva cada ciclo. Teniendo en cuenta este tiempo de
acceso, la latencia inicial de la multiplicación TLI(Mult) = 16 ciclos, y la posibilidad de
encadenar instrucciones vectoriales, el diagrama de tiempos de estas tres instrucciones
es el siguiente:

Ta = 16 LV

TLI(Mult) = 16 MULTV

Ta = 16 SV

Por lo que el tiempo de latencia inicial de la secuencia es de 3·16 = 48 ciclos y el

tiempo por componente es TPC = 1 ciclo. Con estos valores de TLI y TPC y con los
valores de TBASE y TBUCLE que nos dan en el enunciado del problema, podemos calcular
Tk como:

 k 
Tk  TBASE     TLI  TBUCLE   k  TPC  8   k  48  10  k cilos
 MLV  16 

Para calcular el valor de R∞ hay que tener en cuenta que para un vector de tamaño k se
realizarán k/2 operaciones flotantes, ya que solo se opera con los elementos pares, con
lo que debemos la expresión de R∞ queda como
1
k  frecuencia 1
k  500 250k
R  lim Rk  lim 2
 lim 2
 lim  54,054 MFLOPS
k  k  Tk k  k  k  k
8    48  10  k 8    58  k
16  16 