MEMORIA PRACTICA 2 CPA

Trazado de Rayos con OpenMP

M Dolores Novella Escribano

Marcos Ramos Montes

Grupo: L1-3C
Contenido
Planteamiento del Problema ........................................................................................................ 2
Paralelizacin del Cdigo .............................................................................................................. 2
Criterios de planificacin utilizados y medida de prestaciones .................................................... 4
Tablas y grficas ............................................................................................................................ 4
Bibliografa .................................................................................................................................... 7

1
Planteamiento del Problema
Se trata de paralelizar la funcin de renderizacin partiendo de un cdigo
secuencial de trazado de rayos, el funcionamiento general del programa est
descrito en el boletn de la prctica 2.
Atacaremos el problema mediante la paralizacin de bucles, y analizaremos:
- Que bucles es interesante paralelizar y por qu
- Mediremos los tiempos de ejecucin con distintas cantidades de hilos
- Examinaremos como influyen distintos criterios de planificacin de hilos
sobre los tiempos de ejecucin.
- Hablaremos sobre la aceleracin y el grado de eficiencia obtenido.

Pero antes de entrar de lleno en estos detalles es interesante observar

el cdigo paralelizado.

Paralelizacin del Cdigo

La siguiente figura muestra el cdigo completo de la funcin render,
seguidamente vamos a explicar cmo ha sido paralelizado.

void render(const unsigned size, const Sphere *spheres)

{
unsigned width = 640, height = 480;
unsigned width = 1024, height = 768;
Vec3 *image, *pixel, aux, raydir;

Real invWidth = 1 / (Real)width, invHeight = 1 / (Real)height;

Real fov = 30, aspectratio = width / (Real)height;
Real xx, yy, angle = tan(M_PI * 0.5 * fov / 180.0);
unsigned x, y, i;
FILE *F;
image = malloc(width * height * sizeof(*image));
pixel = image;
Vec3_new0(&aux);
// Trace rays
double t;
t = omp_get_wtime();
#pragma omp parallel for private(x,pixel,xx,yy,raydir) schedule(runtime)
for (y = 0; y < height; ++y) {
pixel = &image[width*y];
for (x = 0; x < width; ++x, ++pixel) {
xx = (2 * ((x + 0.5) * invWidth) - 1) * angle * aspectratio;
yy = (1 - 2 * ((y + 0.5) * invHeight)) * angle;
Vec3_new(&raydir, xx, yy, -1);
Vec3_normalize(&raydir);

2
 trace(pixel, &aux, &raydir, size, spheres, 0);
}
}
// Save result to a PPM image (keep these flags if you compile under
Windows)
t = omp_get_wtime() - t;
printf("El programa ha tardado en ejecutarse %lf ciclos de reloj\n", t);
#pragma omp parallel
#pragma omp master

F = fopen("./untitled.ppm", "wb");
fprintf(F, "P6\n%u %u\n255\n", width, height);
for (i = 0; i < width * height; ++i) {
fprintf(F, "%c%c%c",

(unsigned char)(min(1.0, image[i].x) * 255),

(unsigned char)(min(1.0, image[i].y) * 255),

(unsigned char)(min(1.0, image[i].z) * 255));

fclose(F);
free(image);
}

En primer lugar vemos que se paraleliza el bucle ms externo, esto se hace as

por razones de eficiencia ya que la paralelizacin del bucle interno supondra la
creacin de tantos hilos como iteraciones realiza el bucle interno por cada
iteracin del bucle externo. Las variables x,pixel,xx,yy,raydir se declaran
privadas para evitar la aparicin de condiciones de carrera derivadas de la
lectura y escritura de variables compartidas. El uso de la directiva parallel for
implica que las iteraciones del bucle externo se reparten entre los diferentes
hilos, siendo el criterio de planificacin definido en la clusula schedule el que
determina como se llevara a cabo dicho reparto de iteraciones. En este caso el
valor runtime lo que indica es que la planificacin que se utilizara ser leda en
tiempo de ejecucin de la variable de entorno OMP_SCHEDULE.
Por ltimo, la directiva master hace que una regin de cdigo sea ejecutada
solamente por el hilo principal de forma q el resto de hilos se saltan esa
seccin de cdigo. Observes que esto es necesario ya que no tiene sentido
paralelizar una operacin de E/S como en este caso es la escritura en un
fichero.

3
Criterios de planificacin utilizados y medida de prestaciones

Durante la prctica hemos utilizado tres criterios de planificacin distintos:

- Static,0: Se crean tantos bloques como hilos, se le asigna cada hilo un
bloque aproximadamente igual de forma esttica.
- Static,1: Asignacin cclica de bloques de tamao 1
- Dynamic: Los hilos se asignan segn se piden (Su chunk por defecto es
1)
Notar que en el caso del cdigo secuencial todos los tiempos de ejecucin
son iguales ya que existe un nico hilo de ejecucin.
Comentar en este punto que para la toma de tiempos se ha utilizado en
todos los casos, la funcin omp_get_wtime() de OpenMP.

Como conclusin de este apartado, comentar que la planificacin ms

adecuada es la dinmica ya que asigna recursos segn es necesario.

Tablas y grficas

A continuacin se muestran la tabla y la grfica hilos/tiempo para la pla

nificacin dinmica

Tipo de Planificacin 2 4 8 16 32
Dinmica 25.254.617 12.548.299 6.671.400 3.932.046 2.169.226

Planificacin Dinmica
30.000.000

25.000.000
Tiempo De Ejecucin

20.000.000

15.000.000

10.000.000

5.000.000

0
2 4 8 16 32
Hilos

4
 La grafica nos muestra como el tiempo de ejecucin disminuye al aumentar
el nmero de hilos.

Speed up 2 4 8 16 32
1,944546 3,91358 7,36109 12,48937 22,638847

Speed Up
25

20
Aceleracin

15

10

0
2 4 8 16 32
Hilos

La aceleracin global, o Speed Up, nos permite averiguar cul es el grado o

porcentaje de mejora entre el tiempo del programa ejecutado de forma paralela
y el tiempo secuencial. Como podemos apreciar, con 2 hilos la aceleracin no
llega a duplicarse, mientras que con 4 hilos esta casi se cuadruplica

5
Por ltimo, echemos un vistazo a la eficiencia:

Eficiciencia 2 4 8 16 32
0,972273 0,978395 0,920136 0,780586 0,70746397

Eficiencia
1,2

0,8
Eficiencia

0,6

0,4

0,2

0
2 4 8 16 32
Hilos

La eficiencia o grado de aprovechamiento mayor lo observamos con 4 hilos.

Despus conforme aumentamos el nmero de hilos observamos que el
aprovechamiento es menor en comparacin al aumento de hilos. Ello se debe a
que la aceleracin (speed-up) obtenida con esa cantidad de procesadores,
pese a ser un valor elevado, es ineficiente.

6
Bibliografa
Apuntes de teora de CPA
Boletn de la Practica 2
Libro: INTRODUCCIN A LA PROGRAMACIN PARALELA
Autores: FRANCISCO CARMEL ALMEIDA RODRGUEZ, DOMINGO
GIMENEZ CANOVAS, JOS MIGUEL MANTAS RUZ, ANTONIO VIDAL
MACIA
ISBN: 8497326741
Editorial: Paraninfo