Академический Документы
Профессиональный Документы
Культура Документы
Roxana Luque
Nelson Molinas
Ingeniera en Informtica
Facultad Politcnica
Universidad Nacional de Asuncin
San Lorenzo, Paraguay
Ingeniera en Informtica
Facultad Politcnica
Universidad Nacional de Asuncin
San Lorenzo, Paraguay
roxanalu@gmail.com
nelson.molinas@gmail.com
RESUMEN
Palabras Claves
Pthread, OpenMP, MPI, matrices.
1.
INTRODUCCIN
2.
PTHREADS
2.1
3.
OPENMP
3.1
4.
MPI
4.1
5.
OPENMP VERSUS PTHREAD
VERSUS MPI
Se diferencian principalmente en el comportamiento en el nivel
de control que se quiere sobre la paralelizacin. OpenMP es
buensimo si todo lo que se necesita hacer es colocar algunas
directivas #pragma para tener una versin paralela de un cdigo
serial rpidamente. Ahora para realizar cosas ms interesantes
como codificacin de colas complejas, se puede utilizar
OpenMP pero sera ms directa y fcil la utilizacin de Pthreads
[5].
OpenMP provee caractersticas reducidas, es decir se consigue
muchas funcionalidades con mucho menos trabajo.
OpenMP es mucho alto nivel de Pthread. Es fcil de usar, basta
con aadir algunas directivas. Por otro lado, Pthread le da ms
control de su cdigo y se puede aprender y entender lo que est
sucediendo en un algoritmo paralelo.
Las directivas #pragma de OpenMP tienen otra ventaja clave: se
puede deshabilitar el soporte para OpenMP, el cdigo puede ser
compilado como una aplicacin serial.
Ambas API son porttiles, pero Pthreads ofrece una gama
mucho mayor de funciones primitivas que proporcionan un
control ms preciso sobre las operaciones de sobre hilos.
Cabe mencionar que una de las ventajas de Pthreads sobre
OpenMP es que el programador tiene un mayor control sobre la
creacin, destruccin y el comportamiento de los hilos, ya que la
gestin de un hilo est en un nivel ms bajo en Pthreads que en
OpenMP.
En cuanto a MPI se puede decir que necesita que su proceso
maestro haga nicamente un trabajo especfico. La razn detrs
de esto es reducir la sobrecarga en paralelo. Por lo tanto, el
proceso maestro puede centrarse slo en la gestin y
distribucin de datos.
A diferencia de MPI en OpenMP y Pthreads, la gestin de
procesos y sincronizacin se realiza en la misma memoria (es
decir memoria compartida) y no slo el hilo principal sino todos
los hilos tambin son responsables de la sincronizacin de
subprocesos.
Algunas ventajas podran ser que con MPI es ms fcil de
entender cmo se distribuye los datos y cuanto tiempo se uso y
que tiene muchas de las herramientas disponibles para ayudar al
programador. Las desventajas es que tiene una codificacin
compleja de leer, escribir y mantener.
6.
RESULTADOS EXPERIMENTALES
Memoria
4GB
DDR3
Disco Duro
HDD 500GB
7200 rpm
S.O.
Ubuntu
11.05
4 hilos
8 hilos
16 hilos
256
146
76
65
64
512
1210
606
580
577
1024
35060
18572
16726
17087
2048
303670
157734
153238
154699
8 hilos
16 hilos
256
140
70
61
32
512
1414
668
559
522
1024
31743
15793
14245
14381
2048
315383
160211
153761
156366
OPENMP
1000000
100000
256
10000
512
1000
1024
100
2048
10
1
2 hilos
4 hilos
8 hilos
Nro. de Hilos
16 hilos
2 hilos
PTHREADS
1000000
Tiempo de respuesta
4 hilos
Tiempo de respuesta
2 hilos
4 hilos
8 hilos
16 hilos
256
74
89
107
248
512
5389
5629
3916
6360
1024
102987
118514
127213
136503
2048
100000
256
10000
512
1000
1024
100
2048
10
MPI
1
4 hilos
8 hilos
Nro. de Hilos
16 hilos
1000000
Tiempo de respuesta
2 hilos
100000
256
10000
512
1000
1024
100
2048
10
1
2 hilos
4 hilos
8 hilos
Nro. de Hilos
16 hilos
100000
Pthread
80000
OpenMP
60000
MPI
40000
20000
2
4
8
Cantidad de Hilos
16
300
Tiempo de respuesta
120000
250
200
Pthread
150
OpenMP
MPI
100
140000
Para la Figura 6, se puede ver hubo una pequea mejora para las
distintas cantidades de hilos (2, 4, 8 y 16) de OpenMP con
respecto a Pthreads. As tambin se observa que con MPI se
obtiene mayor tiempo de respuesta que los anteriores.
Multiplicacin de matrices de 2048x2048
50
0
4
8
Cantidad de Hilos
350000
16
Tiempo de respuesta
300000
250000
Pthread
200000
OpenMP
150000
MPI
100000
50000
0
2
16
Cantidad de Hilos
Tiempo de respuesta
7000
6000
5000
Pthread
4000
OpenMP
3000
MPI
2000
1000
0
2
4
8
Cantidad de Hilos
16
7.
CONCLUSIONES
8.
REFERENCIAS
[3] http://es.wikipedia.org/wiki/Multiplicaci
%C3%B3n_de_matrices
[4] http://es.wikipedia.org/wiki/OpenMP
[5] http://software.intel.com/en-us/articles/threading-modelsfor-high-performance-computing-pthreads-or-openmp/
[6] D. an Mey, Matrix multiplication using mpi.
9.
9.1
/*
============================================================================
NOMBRE: pthread_mmult.c
AUTORES
Roxana Luque - Nelson Molinas
DESCRIPCION
Multiplicacion de matrices con Pthreads
Universidad Nacional de Asuncion - Facultad Politecnica
Carrera: Ingenieria Informatica
Materia: Electiva V - Algoritmos Paralelos
Profesor: Christian Von Lucken
Anho: 2015
============================================================================
*/
#include
#include
#include
#include
<pthread.h>
<stdlib.h>
<stdio.h>
<sys/timeb.h>
int hilos[4]={2,4,8,16};
int **A, **B, **C;
int TAM;
struct registro{
//Cantidad de hilos
int uno;
int dos;
};
int **crearMatriz() {
int i;
int *valores, **temp;
valores = (int *) malloc (TAM * TAM * sizeof(int));
temp = (int **) malloc (TAM * sizeof(int*));
for(i=0; i < TAM; i++)
temp[i] = &(valores[i * TAM]);
return temp;
}
void cargar_matriz(int **matriz, int TAM)
{
int i, j, n = 0;
for (i=0; i<TAM; i++)
for (j=0; j<TAM; j++)
matriz[i][j] = (int) rand()%100;
}
void* mmult (void* param)
{
struct registro *m_param=(struct registro *)param;
int desde = (m_param->uno * TAM)/m_param->dos;
int hasta = ((m_param->uno+1) * TAM)/m_param->dos;
int i,j,k;
for (i=desde; i<hasta; i++)
for (j=0; j<TAM; j++) {
C[i][j]=0;
for (k=0; k<TAM; k++)
C[i][j] += A[i][k]*B[k][j];
}
return 0;
}
(void) ftime(&t_ini);
thread = (pthread_t *) malloc(hilos[j] * sizeof(pthread_t));
for (i=0; i<hilos[j]; i++)
{
datos->uno=i;
datos->dos=hilos[j];
if (pthread_create (&thread[i], NULL, mmult, datos) != 0 )
{
perror("No se puede crear el hilo");
exit(-1);
}
}
9.2
respuesta
para
%d
procesos
es:
/*
============================================================================
NOMBRE: omp_mmult.c
AUTORES
Roxana Luque - Nelson Molinas
DESCRIPCION
Multiplicacion de matrices con OpenMP
Universidad Nacional de Asuncion - Facultad Politecnica
Carrera: Ingenieria Informatica
Materia: Electiva V - Algoritmos Paralelos
Profesor: Christian Von Lucken
Anho: 2015
============================================================================
*/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <omp.h>
int hilos[4]={2,4,8,16};
int **A, **B, **C;
//Cantidad de hilos
%ld
int TAM;
int **crearMatriz() {
int i;
int *valores, **temp;
valores = (int *) malloc (TAM * TAM * sizeof(int));
temp = (int **) malloc (TAM * sizeof(int*));
for(i=0; i < TAM; i++)
temp[i] = &(valores[i * TAM]);
return temp;
}
void cargar_matriz(int **matriz, int TAM)
{
int i, j, n = 0;
for (i=0; i<TAM; i++)
for (j=0; j<TAM; j++)
matriz[i][j] = (int) rand()%100;
}
#pragma
omp
parallel
shared(A,B,C,nthreads)
num_threads(hilos[l])
{
tid = omp_get_thread_num();
if (tid == 0) {
nthreads = omp_get_num_threads();
}
A = crearMatriz();
B = crearMatriz();
C = crearMatriz();
//Cargando las matrices con valores
cargar_matriz(A, TAM);
cargar_matriz(B, TAM);
private(i,j,k,tid)
if (tid == 0)
ini = omp_get_wtime();
//Multiplicacion
#pragma omp for schedule(static, TAM/hilos[l])
for (i=0; i<TAM; i++)
for (j=0; j<TAM; j++) {
C[i][j]=0;
for (k=0; k<TAM; k++)
C[i][j] += A[i][k]*B[k][j];
}
if (tid == 0) {
fin = omp_get_wtime();
printf("\n\n");
printf("
Tiempo
de
milisegundos.\n", hilos[l], (fin-ini)*1000);
}
}
}
printf("\n");
return 0;
}
9.3
respuesta
para
%d
hilos:
/*
============================================================================
NOMBRE: mpi_mmult.c
%f
AUTOR
Roxana Luque - Nelson Molinas
DESCRIPCION
Multiplicacion de matrices con MPI
Universidad Nacional de Asuncion - Facultad Politecnica
Carrera: Ingenieria Informatica
Materia: Electiva V - Algoritmos Paralelos
Profesor: Christian Von Lucken
Anho: 2015
============================================================================
*/
#include
#include
#include
#include
#include
#include
<mpi.h>
<stdio.h>
<math.h>
<time.h>
<unistd.h>
<stdlib.h>
MPI_Comm_size(MPI_COMM_WORLD, &nroproc);
/* Se establece el identificador del proceso llamador en el comunicador */
MPI_Comm_rank(MPI_COMM_WORLD, &proc);
/* El proceso maestro carga las matrices A y B */
if (proc==0) {
printf("-----------------------------------------\n");
printf("Multiplicacion de matrices de tamanho %d\n",TAM);
printf("-----------------------------------------\n");
cargar_matriz(A);
cargar_matriz(B);
}
MPI_Barrier(MPI_COMM_WORLD);
if (proc==0) {
t_ini = MPI_Wtime();
}
/* MPI_Scatter envia partes diferentes de A del proceso fuente, a cada proceso
incluyendose el mismo */
MPI_Scatter (A, TAM*TAM/nroproc, MPI_INT, A, TAM*TAM/nroproc, MPI_INT, 0,
MPI_COMM_WORLD);
/* MPI_Bcast envia B del proceso maestro a todos los procesos */
MPI_Bcast (B, TAM*TAM, MPI_INT, 0, MPI_COMM_WORLD);
/* Se realiza el computo local en cada proceso */
for (i = 0;i<nroproc; i++)
{
if (proc == i)
{
for
(i
=
proc*(TAM/nroproc);
i
<
(proc*(TAM/nroproc)+
(TAM/nroproc)); i++)
{
for (j = proc*(TAM/nroproc); j < (proc*(TAM/nroproc)+
(TAM/nroproc)); j++)
{
for (k = proc*TAM; k < proc*TAM+TAM; k++)
{
sum = sum + A[i][k] * B[k][j];
}
C[i][j] = sum;
sum = 0;
}
}
}
}
MPI_Gather (C,
MPI_COMM_WORLD);
TAM*TAM/nroproc,
MPI_INT,
C,
TAM*TAM/nroproc,
MPI_INT,
0,
nroproc,