Coleccin de ejercicios Memoria Compartida y OpenMP

Computacin Paralela Grado en Ingeniera Informtica (ETSInf)

1. Paralelismo de bucles
Cuestin 11
Segn las condiciones de Bernstein, indica el tipo de dependencias de datos existente entre las distintas
iteraciones en los casos que se presentan a continuacin. Justifica si se puede eliminar o no esa dependencia
de datos, eliminndola en caso de que sea posible.
(a) for (i=1;i<N-1;i++) {
x[i+1] = x[i] + x[i-1];
}
(b) for (i=0;i<N;i++) {
a[i] = a[i] + y[i];
x = a[i];
}
(c) for (i=N-2;i>=0;i--) {
x[i] = x[i] + y[i+1];
y[i] = y[i] + z[i];
}

Cuestin 12
Dados los siguientes grafos de dependencias de tareas:

T1
T1 T2

T2 T3
T3

T5 T4 T6
T4 T5

T7
T6
T7 T8
1 3
T9 T1 , T7 , T10 3n
T8 3
T2 , T3 , T8 n
T4 , T5 , T6 , T9 2n3
T9 T10

(a) Para el grafo de la izquierda, indica qu secuencia de nodos del grafo constituye el camino crti-
co. Calcula la longitud del camino crtico y el grado medio de concurrencia. Nota: no se ofrece
informacin de costes, se puede suponer que todas las tareas tienen el mismo coste.
(b) Repite el apartado anterior para el grafo de la derecha. Nota: en este caso el coste de cada tarea
viene dado en flops (para un tamao de problema n) segn la tabla mostrada.
Cuestin 13
El siguiente cdigo secuencial implementa el producto de una matriz B de dimensin N N por un
vector c de dimensin N .

void prodmv(double a[N], double c[N], double B[N][N])

{
int i, j;
double sum;
for (i=0; i<N; i++) {
sum = 0;
for (j=0; j<N; j++)
sum += B[i][j] * c[j];
a[i] = sum;
}
}
(a) Realiza una implementacin paralela mediante OpenMP del cdigo anterior.
(b) Calcula los costes computacionales en flops de las implementaciones secuencial y paralela, suponiendo
que el nmero de hilos p es un divisor de N .
(c) Calcula el speedup y la eficiencia del cdigo paralelo.
Cuestin 14
Dada la siguiente funcin:
double funcion(double A[M][N])
{
int i,j;
double suma;
for (i=0; i<M-1; i++) {
for (j=0; j<N; j++) {
A[i][j] = 2.0 * A[i+1][j];
}
}
suma = 0.0;
for (i=0; i<M; i++) {
for (j=0; j<N; j++) {
suma = suma + A[i][j];
}
}
return suma;
}
(a) Indica su coste terico (en flops).
(b) Paralelzalo usando OpenMP. Por qu lo haces as? Se valorarn ms aquellas soluciones que sean
ms eficientes.
(c) Indica el speedup que podr obtenerse con p procesadores suponiendo M y N mltiplos exactos de
p.
(d) Indica una cota superior del speedup (cuando p tiende a infinito) si no se paralelizara la parte que
calcula la suma (es decir, slo se paraleliza la primera parte y la segunda se ejecuta secuencialmente).

Cuestin 15
Dada la siguiente funcin:
 double fun_mat(double a[n][n], double b[n][n])
{
int i,j,k;
double aux,s=0.0;
for (i=0; i<n; i++) {
for (j=0; j<n; j++) {
aux=0.0;
s += a[i][j];
for (k=0; k<n; k++) {
aux += a[i][k] * a[k][j];
}
b[i][j] = aux;
}
}
return s;
}
(a) Indica cmo se paralelizara mediante OpenMP cada uno de los tres bucles. Cul de las tres formas
de paralelizar ser la ms eficiente y por qu?
(b) Suponiendo que se paraleliza el bucle ms externo, indica los costes a priori secuencial y paralelo,
en flops, y el speedup suponiendo que el nmero de hilos (y procesadores) coincide con n.
(c) Aade las lneas de cdigo necesarias para que se muestre en pantalla el nmero de iteraciones que
ha realizado el hilo 0, suponiendo que se paraleliza el bucle ms externo.
Cuestin 16
Implementa un programa paralelo utilizando OpenMP que cumpla los siguientes requisitos:

Pida por teclado un nmero entero positivo n.

Calcule en paralelo la suma de los primeros n nmeros naturales, utilizando para ello una distribucin
dinmica que reparta los nmeros a sumar de 2 en 2, siendo 6 el nmero de hilos usado.
Al final del programa deber imprimir en pantalla el identificador del hilo que ha sumado el ltimo
nmero (n) y la suma total calculada.

Cuestin 17
Dada esta funcin en C:
double fun( int n, double a[], double b[] )
{
int i,ac,bc;
double asuma,bsuma,cota;

asuma = 0; bsuma = 0;
for (i=0; i<n; i++)
asuma += a[i];
for (i=0; i<n; i++)
bsuma += b[i];
cota = (asuma + bsuma) / 2.0 / n;

ac = 0; bc = 0;
for (i=0; i<n; i++) {
if (a[i]>cota) ac++;
if (b[i]>cota) bc++;
 }
return cota/(ac+bc);
}
(a) Paralelzala eficientemente mediante directivas OpenMP (sin alterar el cdigo ya existente).
(b) Indica el coste a priori en flops, tanto secuencial como paralelo (considerando slo operaciones en
coma flotante y asumiendo que una comparacin implica una resta). Cul sera el speed-up y la
eficiencia para p procesadores? Asumir que n es un mltiplo exacto de p.
Cuestin 18
Se quiere paralelizar de forma eficiente la siguiente funcin mediante OpenMP.
#define EPS 1e-16
#define DIMN 128
int fun(double a[DIMN][DIMN], double b[], double x[], int n, int nMax)
{
int i, j, k;
double err=100, aux[DIMN];

for (i=0;i<n;i++)
aux[i]=0.0;

for (k=0;k<nMax && err>EPS;k++) {

err=0.0;
for (i=0;i<n;i++) {
x[i]=b[i];
for (j=0;j<i;j++)
x[i]-=a[i][j]*aux[j];
for (j=i+1;j<n;j++)
x[i]-=a[i][j]*aux[j];
x[i]/=a[i][i];
err+=fabs(x[i]-aux[i]);
}
for (i=0;i<n;i++)
aux[i]=x[i];
}
return k<nMax;
}
(a) Paralelzala de forma eficiente.
(b) Calcula el coste computacional de una iteracin del bucle k. Calcula el coste computacional de la
versin paralela (asumiendo que se divide el nmero de iteraciones de forma exacta entre el nmero
de procesos) y el speed-up.
Cuestin 19
Dada la siguiente funcin:

#define DIM 6000

#define PASOS 6

double funcion1(double A[DIM][DIM], double b[DIM], double x[DIM])

{
int i, j, k, n=DIM, pasos=PASOS;
 double max=-1.0e308, q, s, x2[DIM];
for (k=0;k<pasos;k++) {
q=1;
for (i=0;i<n;i++) {
s = b[i];
for (j=0;j<n;j++)
s -= A[i][j]*x[j];
x2[i] = s;
q *= s;
}
for (i=0;i<n;i++)
x[i] = x2[i];
if (max<q)
max = q;
}
return max;
}
(a) Paraleliza el cdigo usando OpenMP. Por qu lo haces as? Se valorarn ms aquellas soluciones
que sean ms eficientes.
(b) Indica el coste terico (en flops) que tendra una iteracin del bucle k del cdigo secuencial.
(c) Considerando una nica iteracin del bucle k (PASOS=1), indica el speedup y la eficiencia que podr
obtenerse con p hilos, suponiendo que hay tantos ncleos/procesadores como hilos y que DIM es un
mltiplo exacto de p.

Cuestin 110
Dada la siguiente funcin:
double funcion(double A[M][N], double b[N], double c[M], double z[N])
{
double s, s2=0.0, elem;
int i, j;

for (i=0; i<M; i++) {

s = 0.0;
for (j=0; j<N; j++)
s = s + A[i][j]*b[j];
elem = s*s;
if (elem>c[i])
c[i] = elem;
s2 = s2+s;
}

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

z[i] = 2.0/3.0*b[i];

return s2;
}
(a) Paralelzala con OpenMP de forma eficiente. Utiliza si es posible una sola regin paralela.
(b) Haz que cada hilo muestre una lnea con su identificador y el nmero de iteraciones del primer bucle
i que ha realizado.
 (c) En el primer bucle paralelizado, justifica si cabe esperar diferencias en prestaciones entre las siguien-
tes planificaciones para el bucle: schedule(static), schedule(static,1), schedule(dynamic).
Cuestin 111
double func(double x[], double A[N][N]) {
int i, j, acierto;
double elem, valor=0;
for (i=0; i<N; i++) {
elem = x[i];
acierto = 0;
j = N-1;
while (j>=0 && !acierto) {
if (elem<sqrt(A[i][j])) acierto = 1;
j--;
}
if (acierto) {
elem *= 2.0;
x[i] /= 2.0;
valor += elem;
}
}
return valor;
}
(a) Paraleliza con OpenMP (de forma eficiente) el bucle i de la funcin dada.
(b) Paraleliza con OpenMP (de forma eficiente) el bucle j de la funcin dada.
Cuestin 112
Dada la siguiente funcin:
void funcion(double A[N][N], double x[N], double b[N])
{
int i,j;
double y[N];

for (i=0; i<N; i++) {

y[i]=b[i];
for (j=0; j<i; j++) {
y[i]-=A[i][j]*y[j];
}
}
for (i=N-1; i>=0; i--) {
x[i]=y[i];
for (j=i+1; j<N; j++) {
x[i]-=A[i][j]*x[j];
}
x[i]/=A[i][i];
}
}
(a) Indica su coste terico (en flops).
(b) Paralelzala usando OpenMP. Por qu lo haces as? Se valorarn ms aquellas soluciones que sean
ms eficientes.
2. Regiones paralelas
Cuestin 21
Dada la siguiente funcin, que busca un valor en un vector, paralelzala usando OpenMP. Al igual que
la funcin de partida, la funcin paralela deber terminar la bsqueda tan pronto como se encuentre el
elemento buscado.
int busqueda(int x[], int n, int valor)
{
int encontrado=0, i=0;
while (!encontrado && i<n) {
if (x[i]==valor) encontrado=1;
i++;
}
return encontrado;
}

Cuestin 22
Dado un vector v de n elementos, la siguiente funcin calcula su 2-norma kvk, definida como:
v
u n
uX
kvk = t v2 i
i=1

double norma(double v[], int n)

{
int i;
double r=0;
for (i=0; i<n; i++)
r += v[i]*v[i];
return sqrt(r);
}
(a) Paralelizar la funcin anterior mediante OpenMP, siguiendo el siguiente esquema:
En una primera fase, se quiere que cada hilo calcule la suma de cuadrados de un bloque de n/p
elementos del vector v (siendo p el nmero de hilos). Cada hilo dejar el resultado en la posicin
correspondiente de un vector sumas de p elementos. Se puede asumir que el vector sumas ya ha
sido creado (aunque no inicializado).
En una segunda fase, uno de los hilos calcular la norma del vector, a partir de las sumas
parciales almacenadas en el vector sumas.
(b) Paralelizar la funcin de partida mediante OpenMP, usando otra aproximacin distinta de la del
apartado anterior.
(c) Calcular el coste a priori del algoritmo secuencial de partida. Razonar cul sera el coste del algoritmo
paralelo del apartado a, y el speedup obtenido.
Cuestin 23
Escribe un programa que realice un bucle con 100 iteraciones (de 0 a 99) en paralelo usando la planificacin
indicada en la variable de entorno OMP_SCHEDULE. El programa deber mostrar por pantalla los ndices
de la primera y ltima iteraciones que haya realizado cada hilo.
Por ejemplo, si lo ejecutamos con 2 hilos y una planificacin esttica sin chunk, debera salir por pantalla:
Hilo 0: primera=0 ltima=49
Hilo 1: primera=50 ltima=99
Cuestin 24
Dada la siguiente funcin:
void f(int n, double a[], double b[])
{
int i;
for (i=0; i<n; i++) {
b[i]=cos(a[i]);
}
}
Paralelzala, haciendo adems que cada hilo escriba un mensaje indicando su nmero de hilo y cuntas
iteraciones ha procesado. Se quiere mostrar un solo mensaje por cada hilo.

Cuestin 25
Dada la funcin:
int f(int n, double x[], double y[])
{
int i, cont=0;
for (i=0; i<n; i++) {
if (x[i]>0) {
y[i]=f2(x[i]);
cont++;
}
}
return cont;
}
Paralelzala, haciendo adems que cada hilo escriba un mensaje indicando su nmero de hilo y cuntas
veces dicho hilo ha invocado a la funcin f2. Se quiere mostrar un solo mensaje por cada hilo.

Cuestin 26
Dada la siguiente funcin:
void normaliza(double A[N][N])
{
int i,j;
double suma=0.0,factor;
for (i=0; i<N; i++) {
for (j=0; j<N; j++) {
suma = suma + A[i][j]*A[i][j];
}
}
factor = 1.0/sqrt(suma);
for (i=0; i<N; i++) {
for (j=0; j<N; j++) {
A[i][j] = factor*A[i][j];
}
}
}
(a) Paralelzala con OpenMP usando dos regiones paralelas.
 (b) Paralelzala con OpenMP usando una nica regin paralela que englobe a todos los bucles. En este
caso, tendra sentido utilizar la clusula nowait? Justifica la respuesta.
Cuestin 27
Dada la siguiente funcin:
double ej(double x[M], double y[N], double A[M][N])
{
int i,j;
double aux,s=0.0;
for (i=0; i<M; i++)
x[i] = x[i]*x[i];
for (i=0; i<N; i++)
y[i] = 1.0+y[i];
for (i=0; i<M; i++)
for (j=0; j<N; j++) {
aux = x[i]-y[j];
A[i][j] = aux;
s += aux;
}
return s;
}
(a) Paralelzala eficientemente mediante OpenMP.
(b) Calcula el nmero de flops de la funcin inicial y de la funcin paralelizada.
(c) Determina el speedup y la eficiencia.

Cuestin 28
Dada la siguiente funcin:
double funcion(int n, double u[], double v[], double w[], double z[])
{
int i;
double sv,sw,res;

calcula_v(n,v); /* tarea 1 */
calcula_w(n,w); /* tarea 2 */
calcula_z(n,z); /* tarea 3 */
calcula_u(n,u,v,w,z); /* tarea 4 */
sv = 0;
for (i=0; i<n; i++) sv = sv + v[i]; /* tarea 5 */
sw = 0;
for (i=0; i<n; i++) sw = sw + w[i]; /* tarea 6 */
res = sv+sw;
for (i=0; i<n; i++) u[i] = res*u[i]; /* tarea 7 */
return res;
}
Las funciones calcula_X tienen como entrada los vectores que reciben como argumentos y con ellos
modifican el vector X indicado. Cada funcin nicamente modifica el vector que aparece en su nombre.
Por ejemplo, la funcin calcula_u utiliza los vectores v, w y z para realizar unos clculos que guarda en
el vector u, pero no modifica ni v, ni w, ni z.
 Esto implica, por ejemplo, que las funciones calcula_v, calcula_w y calcula_z son independientes y
podran realizarse simultneamente. Sin embargo, la funcin calcula_u necesita que hayan terminado
las otras, porque usa los vectores que ellas rellenan (v,w,z).
(a) Dibuja el grafo de dependencias de las diferentes tareas.
(b) Paraleliza la funcin de forma eficiente.
(c) Si suponemos que el coste de todas las funciones calcula_X es el mismo y que el coste de los bucles
posteriores es despreciable, cul sera el speedup mximo posible?

Cuestin 29
Paraleliza el siguiente fragmento de cdigo mediante secciones de OpenMP. El segundo argumento de las
funciones fun_ es de entrada-salida, es decir, estas funciones utilizan y modifican el valor de a.
int n=...;
double a,b[3];

a = -1.8;
fun1(n,&a);
b[0] = a;
a = 3.2;
fun2(n,&a);
b[1] = a;
a = 0.25;
fun3(n,&a);
b[2] = a;

Cuestin 210
Dada la siguiente funcin:
void func(double a[],double b[],double c[],double d[])
{ f1(a,b);
f2(b,b);
f3(c,d);
f4(d,d);
f5(a,a,b,c,d);
}
El primer argumento de todas las funciones usadas es de salida y el resto de argumentos son argumentos
de entrada. Por ejemplo, f1(a,b) es una funcin que a partir del vector b modifica el vector a.
(a) Dibuja el grafo de dependencias de tareas e indica al menos 2 tipos diferentes de dependencias que
aparezcan en este problema.
(b) Paraleliza la funcin mediante directivas OpenMP.
(c) Suponiendo que todas las funciones tienen el mismo coste y que se dispone de un nmero de proce-
sadores arbitrario, cul ser el speedup mximo posible?
Cuestin 211
En la siguiente funcin, T1, T2, T3 modifican x, y, z, respectivamente.
double f(double x[], double y[], double z[], int n)
{
int i, j;
double s1, s2, a, res;
 T1(x,n); /* Tarea 1 */
T2(y,n); /* Tarea 2 */
T3(z,n); /* Tarea 3 */

/* Tarea 4 */
for (i=0; i<n; i++) {
s1=0;
for (j=0; j<n; j++) s1+=x[i]*y[i];
for (j=0; j<n; j++) x[i]*=s1;
}

/* Tarea 5 */
for (i=0; i<n; i++) {
s2=0;
for (j=0; j<n; j++) s2+=y[i]*z[i];
for (j=0; j<n; j++) z[i]*=s2;
}

/* Tarea 6 */
a=s1/s2;
res=0;
for (i=0; i<n; i++) res+=a*z[i];
return res;
}
(a) Dibuja el grafo de dependencia de las tareas.
(b) Realiza una paralelizacin mediante OpenMP a nivel de tareas (no de bucles), basndote en el grafo
de dependencias.
(c) Indica el coste a priori del algoritmo secuencial, el del algoritmo paralelo y el speedup resultante.
Supn que el coste de las tareas 1, 2 y 3 es de 2n2 flops cada una.
Cuestin 212
Dado el siguiente fragmento de cdigo:

minx = minimo(x,n); /* T1 */
maxx = maximo(x,n); /* T2 */
calcula_z(z,minx,maxx,n); /* T3 */
calcula_y(y,x,n); /* T4 */
calcula_x(x,y,n); /* T5 */
calcula_v(v,z,x); /* T6 */
(a) Dibuja el grafo de dependencias de las tareas, teniendo en cuenta que las funciones minimo y maximo
no modifican sus argumentos, mientras que las dems funciones modifican slo su primer argumento.
(b) Paraleliza el cdigo mediante OpenMP.
(c) Si el coste de las tareas es de n flops, excepto el de la tarea 4 que es de 2n flops, indica la lon-
gitud del camino crtico y el grado medio de concurrencia. Obtn el speedup y la eficiencia de la
implementacin del apartado anterior, si se ejecutara con 5 procesadores.
Cuestin 213
Se quiere paralelizar el siguiente programa mediante OpenMP, donde genera es una funcin previamente
definida en otro lugar.
 double fun1(double a[],int n, double compara(double x[],double y[],int n)
int v0) {
{ int i;
int i; double s=0;
a[0] = v0; for (i=0;i<n;i++)
for (i=1;i<n;i++) s += fabs(x[i]-y[i]);
a[i] = genera(a[i-1],i); return s;
} }

/* fragmento del programa principal (main) */

int i, n=10;
double a[10], b[10], c[10], x=5, y=7, z=11, w;
fun1(a,n,x); /* T1 */
fun1(b,n,y); /* T2 */
fun1(c,n,z); /* T3 */
x = compara(a,b,n); /* T4 */
y = compara(a,c,n); /* T5 */
z = compara(c,b,n); /* T6 */
w = x+y+z; /* T7 */
printf("w:%f\n", w);
(a) Paraleliza el cdigo de forma eficiente a nivel de bucles.
(b) Dibuja el grafo de dependencias de tareas, segn la numeracin de tareas indicada en el cdigo.
(c) Paraleliza el cdigo de forma eficiente a nivel de tareas, a partir del grafo de dependencias anterior.
(d) Obtn el tiempo secuencial (asume que una llamada a las funciones genera y fabs cuesta 1 flop) y
el tiempo paralelo para cada una de las dos versiones asumiendo que hay 3 procesadores. Calcular
el speed-up en cada caso.

Cuestin 214
Paraleliza mediante OpenMP el siguiente fragmento de cdigo, donde f y g son dos funciones que toman
3 argumentos de tipo double y devuelven un double, y fabs es la funcin estndar que devuelve el valor
absoluto de un double.

double x,y,z,w=0.0;
double x0=1.0,y0=3.0,z0=2.0; /* punto inicial */
double dx=0.01,dy=0.01,dz=0.01; /* incrementos */

x=x0;y=y0;z=z0; /* busca en x */
while (fabs(f(x,y,z))<fabs(g(x0,y0,z0))) x += dx;
w += (x-x0);

x=x0;y=y0;z=z0; /* busca en y */
while (fabs(f(x,y,z))<fabs(g(x0,y0,z0))) y += dy;
w += (y-y0);

x=x0;y=y0;z=z0; /* busca en z */
while (fabs(f(x,y,z))<fabs(g(x0,y0,z0))) z += dz;
w += (z-z0);

printf("w = %g\n",w);
Cuestin 215
Teniendo en cuenta la definicin de las siguientes funciones:
/* producto matricial C = A*B */
void matmult(double A[N][N], /* simetriza una matriz como A+A */
double B[N][N],double C[N][N]) void simetriza(double A[N][N])
{ {
int i,j,k; int i,j;
double suma; double suma;
for (i=0; i<N; i++) { for (i=0; i<N; i++) {
for (j=0; j<N; j++) { for (j=0; j<=i; j++) {
suma = 0.0; suma = A[i][j]+A[j][i];
for (k=0; k<N; k++) { A[i][j] = suma;
suma = suma + A[i][k]*B[k][j]; A[j][i] = suma;
} }
C[i][j] = suma; }
} }
}
}
se pretende paralelizar el siguiente cdigo:
matmult(X,Y,C1); /* T1 */
matmult(Y,Z,C2); /* T2 */
matmult(Z,X,C3); /* T3 */
simetriza(C1); /* T4 */
simetriza(C2); /* T5 */
matmult(C1,C2,D1); /* T6 */
matmult(D1,C3,D); /* T7 */
(a) Realiza una paralelizacin basada en los bucles.
(b) Dibuja el grafo de dependencias de tareas, considerando en este caso que las tareas son cada una de
las llamadas a matmult y simetriza. Indica cul es el grado mximo de concurrencia, la longitud
del camino crtico y el grado medio de concurrencia. Nota: para determinar estos ltimos valores, es
necesario obtener el coste en flops de ambas funciones.
(c) Realiza la paralelizacin basada en secciones, a partir del grafo de dependencias anterior.
Cuestin 216
Dada la siguiente funcin:
double f(int n, double vec[])
{
double res, v[NMAX], w[NMAX];
A(n,v,vec); /* Copia vec en v, coste n */
B(n,w,vec); /* Copia vec en w, coste n */
C(n,vec); /* Actualiza vec, coste n */
D(n,vec); /* Actualiza vec, coste n */
E(n,v); /* Actualiza v, coste 3n */
F(n,w); /* Actualiza w, coste 2n */
res = G(n,vec,v,w); /* Calcula res, coste 3n */
return res;
}
(a) Dibuja el grafo de dependencias, indicando el grado mximo de concurrencia, la longitud del camino
crtico y el grado medio de concurrencia.
 (b) Paralelzala con OpenMP.
(c) Calcula el speedup y la eficiencia mximos si se ejecuta con 2 hilos.

Cuestin 217
void updatemat(double A[N][N])
{
int i,j;
double s[N];
for (i=0; i<N; i++) { /* suma de filas */
s[i] = 0.0;
for (j=0; j<N; j++)
s[i] += A[i][j];
}
for (i=1; i<N; i++) /* suma prefija */
s[i] += s[i-1];
for (j=0; j<N; j++) { /* escalado de columnas */
for (i=0; i<N; i++)
A[i][j] *= s[j];
}
}
(a) Indica el coste terico (en flops) de la funcin proporcionada.
(b) Paralelzala con OpenMP con una nica regin paralela.
(c) Indica el speedup que podr obtenerse con p procesadores suponiendo que N es mltiplo exacto de
p.

Cuestin 218
Dada la siguiente funcin:
double calcula()
{
double A[N][N],B[N][N],a,b,x,y,z;

rellena(A,B); /* T1 */
a = calculos(A); /* T2 */
b = calculos(B); /* T3 */
x = suma_menores(B,a); /* T4 */
y = suma_en_rango(B,a,b); /* T5 */
z = x + y; /* T6 */
return z;
}

La funcin rellena recibe dos matrices y las rellena con valores generados internamente. Los parmetros
del resto de funciones son slo de entrada (no se modifican). Las funciones rellena y suma_en_rango
tienen un coste de 2n2 flops cada una (n = N), mientras que el coste de cada una de las otras funciones
es n2 flops.
(a) Dibuja el grafo de dependencias e indica su grado mximo de concurrencia, un camino crtico y su
longitud y el grado medio de concurrencia.
(b) Paraleliza la funcin con OpenMP.
(c) Calcula el tiempo de ejecucin secuencial, el tiempo de ejecucin paralelo, el speed-up y la eficiencia
del cdigo del apartado anterior, suponiendo que se trabaja con 3 hilos.
Cuestin 219
Se quiere paralelizar el siguiente cdigo de procesado de imgenes, que recibe como entrada 4 imgenes
similares (por ejemplo, fotogramas de un vdeo f1, f2, f3, f4) y devuelve dos imgenes resultado (r1,
r2). Los pxeles de la imagen se representan como nmeros en coma flotante (image es un nuevo tipo de
datos consistente en una matriz de NM doubles).
typedef double image[N][M];

void procesa(image f1,image f2,image f3,image f4,image r1,image r2)

{
image d1,d2,d3;
difer(f2,f1,d1); /* Tarea 1 */
difer(f3,f2,d2); /* Tarea 2 */
difer(f4,f3,d3); /* Tarea 3 */
suma(d1,d2,d3,r1); /* Tarea 4 */
difer(f4,f1,r2); /* Tarea 5 */
}
void difer(image a,image b,image d) void suma(image a,image b,image c,image s)
{ {
int i,j; int i,j;
for (i=0;i<N;i++) for (i=0;i<N;i++)
for (j=0;j<M;j++) for (j=0;j<M;j++)
d[i][j] = fabs(a[i][j]-b[i][j]); s[i][j] = a[i][j]+b[i][j]+c[i][j];
} }
(a) Dibuja el grafo de dependencias de tareas, e indica cul sera el grado mximo y medio de concu-
rrencia, teniendo en cuenta el coste en flops (supon que fabs no realiza ningn flop).
(b) Paraleliza la funcin procesa mediante OpenMP, sin modificar difer y suma.

3. Sincronizacin
Cuestin 31
Sea el siguiente cdigo que permite ordenar un vector v de n nmeros reales ascendentemente:

int ordenado = 0;
double a;
while( !ordenado ) {
ordenado = 1;
for( i=0; i<n-1; i+=2 ) {
if( v[i]>v[i+1] ) {
a = v[i];
v[i] = v[i+1];
v[i+1] = a;
ordenado = 0;
}
}
for( i=1; i<n-1; i+=2 ) {
if( v[i]>v[i+1] ) {
a = v[i];
v[i] = v[i+1];
v[i+1] = a;
ordenado = 0;
 }
}
}
(a) Introducir las directivas OpenMP que permitan ejecutar este cdigo en paralelo.
(b) Modificar el cdigo para contabilizar el nmero de intercambios que se producen, es decir, el nmero
de veces que se entra en cualquiera de las dos estructuras if.
Cuestin 32
Dada la funcin:
void f(int n, double v[], double x[], int ind[])
{
int i;
for (i=0; i<n; i++) {
x[ind[i]] = MAX(x[ind[i]],f2(v[i]));
}
}
Paralelizar la funcin, teniendo en cuenta que f2 es una funcin muy costosa. Se valorar que la solucin
aportada sea eficiente.
Notas. Se asume que f2 no tiene efectos laterales y su resultado slo depende de su argumento de entrada.
El tipo de retorno de la funcin f2 es double. La macro MAX devuelve el mximo de dos nmeros.
Cuestin 33
Dada la siguiente funcin, la cual busca un valor en un vector
int buscar(int x[], int n, int valor)
{
int i, pos=-1;

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

if (x[i]==valor)
pos=i;

return pos;
}
Se pide paralelizarla mediante OpenMP. En caso de varias ocurrencias del valor en el vector, el algoritmo
paralelo debe devolver lo mismo que el secuencial.

Cuestin 34
La infinito-norma de una matriz A Rnn se define como el mximo de las sumas de los valores absolutos
de los elementos de cada fila:
n1
X
kAk = max |ai,j |
i=0,...,n1
j=0

El siguiente cdigo secuencial implementa dicha operacin para el caso de una matriz cuadrada.
#include <math.h>
#define DIMN 100

double infNorm(double A[DIMN][DIMN], int n)

{
 int i,j;
double s,norm=0;

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

s = 0;
for (j=0; j<n; j++)
s += fabs(A[i][j]);
if (s>norm)
norm = s;
}
return norm;
}
(a) Realiza una implementacin paralela mediante OpenMP de dicho algoritmo. Justifica la razn por
la que introduces cada cambio.
(b) Calcula el coste computacional (en flops) de la versin original secuencial y de la versin paralela
desarrollada.
Nota: Se puede asumir que la dimensin de la matriz n es un mltiplo exacto del nmero de hilos
p.
Nota 2: Se puede asumir que el coste de la funcin fabs es de 1 Flop.
(c) Calcula el speedup y la eficiencia del cdigo paralelo ejecutado en p procesadores.

Cuestin 35
Implementa dos funciones paralelas que calculen el factorial de un nmero:
(a) Utilizando reduccin.
(b) Sin utilizar reduccin.

Cuestin 36
Se quiere paralelizar de forma eficiente la siguiente funcin mediante OpenMP.
int cmp(int n, double x[], double y[], int z[])
{
int i, v, iguales=0;
double aux;
for (i=0; i<n; i++) {
aux = x[i] - y[i];
if (aux > 0) v = 1;
else if (aux < 0) v = -1;
else v = 0;
z[i] = v;
if (v == 0) iguales++;
}
return iguales;
}
(a) Paralelzala utilizando construcciones de tipo parallel for.
(b) Paralelzala sin usar ninguna de las siguientes primitivas: for, section, reduction.
Cuestin 37
Dado el siguiente fragmento de cdigo, donde el vector de ndices ind contiene valores enteros entre 0 y
m 1 (siendo m la dimensin de x), posiblemente con repeticiones:
 for (i=0; i<n; i++) {
s = 0;
for (j=0; j<i; j++) {
s += A[i][j]*b[j];
}
c[i] = s;
x[ind[i]] += s;
}
(a) Realiza una implementacin paralela mediante OpenMP, en la que se reparten las iteraciones del
bucle externo.
(b) Realiza una implementacin paralela mediante OpenMP, en la que se reparten las iteraciones del
bucle interno.
(c) Para la implementacin del apartado (a), indica si cabe esperar que haya diferencias de prestaciones
dependiendo de la planificacin empleada. Si es as, qu planificaciones seran mejores y por qu?
Cuestin 38
La siguiente funcin normaliza los valores de un vector de nmeros reales positivos de forma que los
valores finales queden entre 0 y 1, utilizando el mximo y el mnimo.
void normalize(double *a, int n)
{
double max, min, factor;
int i;

max = a[0];
for (i=1;i<n;i++) {
if (max<a[i]) max=a[i];
}
min = a[0];
for (i=1;i<n;i++) {
if (min>a[i]) min=a[i];
}
factor = max-min;
for (i=0;i<n;i++) {
a[i]=(a[i]-min)/factor;
}
}
(a) Paraleliza el programa con OpenMP de la manera ms eficiente posible, mediante una nica regin
paralela. Suponemos un valor de n muy grande y se quiere que la paralelizacin funcione para un
nmero arbitrario de hilos.
(b) Incluye el cdigo necesario para que se imprima una sola vez el nmero de hilos utilizados.
Cuestin 39
Dada la siguiente funcin:
int funcion(int n, double v[])
{
int i,pos_max=-1;
double suma,norma,aux,max=-1;

suma = 0;
for (i=0;i<n;i++)
 suma = suma + v[i]*v[i];
norma = sqrt(suma);

for (i=0;i<n;i++)
v[i] = v[i] / norma;

for (i=0;i<n;i++) {
aux = v[i];
if (aux < 0) aux = -aux;
if (aux > max) {
pos_max = i; max = aux;
}
}
return pos_max;
}
(a) Paralelzala con OpenMP, usando una nica regin paralela.
(b) Tendra sentido poner una clusula nowait a alguno de los bucles? Por qu? (Justifica cada bucle
separadamente.)
(c) Qu aadiras para garantizar que en todos los bucles las iteraciones se reparten de 2 en 2 entre
los hilos?
Cuestin 310
La siguiente funcin procesa una serie de transferencias bancarias. Cada transferencia tiene una cuenta
origen, una cuenta destino y una cantidad de dinero que se mueve de la cuenta origen a la cuenta destino.
La funcin actualiza la cantidad de dinero de cada cuenta (array saldos), y adems devuelve la cantidad
mxima que se transfiere en una sola operacin.
double transferencias(double saldos[], int origenes[], int destinos[],
double cantidades[], int n)
{
int i, i1, i2;
double dinero, maxtransf=0;

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

/* Procesar transferencia i: La cantidad transferida es cantidades[i],
* que se mueve de la cuenta origenes[i] a la cuenta destinos[i]. Se
* actualizan los saldos de ambas cuentas, y la cantidad maxima */
i1 = origenes[i];
i2 = destinos[i];
dinero = cantidades[i];
saldos[i1] -= dinero;
saldos[i2] += dinero;
if (dinero>maxtransf) maxtransf = dinero;
}
return maxtransf;
}
(a) Paraleliza la funcin de forma eficiente mediante OpenMP.
(b) Modifica la solucin del apartado anterior para que se imprima el ndice de la transferencia con ms
dinero.
Cuestin 311
Sea la siguiente funcin:
 double funcion(double A[N][N],double B[N][N])
{
int i,j;
double aux, maxi;
for (i=1; i<N; i++) {
for (j=0; j<N; j++) {
A[i][j] = 2.0+A[i-1][j];
}
}
for (i=0; i<N-1; i++) {
for (j=0; j<N-1; j++) {
B[i][j] = A[i+1][j]*A[i][j+1];
}
}
maxi = 0.0;
for (i=0; i<N; i++) {
for (j=0; j<N; j++) {
aux = B[i][j]*B[i][j];
if (aux>maxi)
maxi = aux;
}
}
return maxi;
}
(a) Paraleliza el cdigo anterior usando para ello OpenMP. Explica las decisiones que tomes. Se valorarn
ms aquellas soluciones que sean ms eficientes.
(b) Calcula el coste secuencial, el coste paralelo, el speedup y la eficiencia que podrn obtenerse con p
procesadores suponiendo que N es divisible entre p.
Cuestin 312
La siguiente funcin calcula los puntos obtenidos por los distintos equipos de una liga de ftbol.
Durante la temporada ha habido NJ jornadas, en cada una de las cuales se han jugado NPJ partidos. La
informacin de todos los partidos se encuentra almacenada en la matriz partidos, cada elemento de la
cual es una estructura de datos (SPartido) que contiene los datos del partido (equipos que lo juegan y
goles de cada uno).
Con esa informacin, la funcin calcula los puntos que le corresponden a cada uno de los NE equipos,
teniendo en cuenta que un equipo consigue 3 puntos si gana un partido, 1 si lo empata, y cero si lo pierde.
Adems, la funcin devuelve el nmero de goles de la temporada y obtiene tambin, para cada jornada,
el mximo nmero de goles en un partido (array maxg_jornada).
int func(SPartido partidos[NJ][NPJ], int puntos[NE], int maxg_jornada[NJ]) {
int i, j, maxg, eq1, eq2, g1, g2, goles_temporada;
goles_temporada = 0;
for (i=0; i<NJ; i++) { /* para cada jornada */
maxg = 0;
for (j=0; j<NPJ; j++) { /* para cada partido de la jornada */
eq1 = partidos[i][j].eq1;
eq2 = partidos[i][j].eq2;
g1 = partidos[i][j].goles1;
g2 = partidos[i][j].goles2;
if (g1>g2)
puntos[eq1] += 3; /* Equipo 1 ha ganado */
 else if (g1<g2)
puntos[eq2] += 3; /* Equipo 2 ha ganado */
else {
puntos[eq1] += 1; /* Empate */
puntos[eq2] += 1;
}
if (g1+g2>maxg) maxg = g1+g2;
goles_temporada += g1+g2;
}
maxg_jornada[i] = maxg;
}
return goles_temporada;
}
(a) Paraleliza (de forma eficiente) el bucle i.
(b) Paraleliza (de forma eficiente) el bucle j. Hay que tener en cuenta que en una misma jornada cada
equipo juega un solo partido. Indica claramente los cambios respecto al cdigo original (no respecto
al apartado anterior).
Cuestin 313
La siguiente funcin proporciona todas las posiciones de fila y columna en las que se encuentra repetido
el valor mximo de una matriz:
void funcion(double A[N][N],double posiciones[][2]) {
int i,j,k=0;
double maximo;
/* Calculamos el mximo */
maximo = A[0][0];
for (i=0;i<N;i++) {
for (j=0;j<N;j++) {
if (A[i][j]>maximo) maximo = A[i][j];
}
}
/* Una vez localizado el mximo, buscamos sus posiciones */
for (i=0;i<N;i++) {
for (j=0;j<N;j++) {
if (A[i][j] == maximo) {
posiciones[k][0] = i;
posiciones[k][1] = j;
k = k+1;
}
}
}
}
(a) Paraleliza dicha funcin de forma eficiente mediante OpenMP, empleado una nica regin paralela.
(b) Modifica el cdigo del apartado anterior para que cada hilo imprima por pantalla su identificador y
la cantidad de valores mximos que ha encontrado y ha incorporado a la matriz posiciones.
Cuestin 314
Se dispone de una matriz M que almacena, en cada fila, la informacin de uno de los NJ componentes
de un equipo de baloncesto, para cada uno de los NP partidos de la temporada. Ms en detalle, cada fila
de la matriz almacena, en sus 4 columnas, el dorsal del jugador (numeracin consecutiva de 0 a NJ-1), el
nmero de puntos anotados en dicho partido, el nmero de rebotes conseguidos y el nmero de tapones
logrados. Todos los jugadores no juegan la misma cantidad de partidos. De hecho, si un jugador no juega
un partido, el nmero de puntos recogidos en la posicin correspondiente de la matriz ser igual a -1.
La valoracin individual de un jugador por cada partido se calcula de este modo:

valoracion = puntos + 1,5 rebotes + 2 tapones

Paraleliza, mediante OpenMP y con una nica regin paralela, la siguiente funcin encargada de obtener
y mostrar por pantalla el jugador que ms puntos ha anotado en un partido, adems de calcular y escribir
en un fichero la valoracin media de cada jugador del equipo. Dicha valoracin deber aparecer ordenada
de menor a mayor de acuerdo al dorsal del jugador, tal y como aparecera si ejecutamos la funcin en
secuencial.
void escribe_valoracion(double M[][4]) {
int i,jugador,puntos,rebotes,tapones,max_puntos,max_anotador;
double suma_valoracion[NJ],valoracion_media[NJ];
int num_partidos[NJ];
...
max_puntos=0;
for (i=0;i<NP*NJ;i++) {
jugador = M[i][0];
puntos = M[i][1];
rebotes = M[i][2];
tapones = M[i][3];
if (puntos!=-1) { /* El jugador ha jugado el partido */
suma_valoracion[jugador] += puntos+1.5*rebotes+2*tapones;
num_partidos[jugador]++;
if (puntos>max_puntos) {
max_puntos=puntos;
max_anotador = jugador;
}
}
}
printf("Maximo anotador: jugador %d (%d puntos)\n",max_anotador,max_puntos);
for (i=0;i<NJ;i++) {
if (num_partidos[i]==0)
valoracion_media[i] = 0;
else
valoracion_media[i] = suma_valoracion[i]/num_partidos[i];
fprintf(fichero,"%d %.2f\n",i,valoracion_media[i]);
}
...
}