e5 pthread openmp mpi molinas luque

7/25/2019 E5 Pthread OpenMP MPI Molinas Luque

http://slidepdf.com/reader/full/e5-pthread-openmp-mpi-molinas-luque 1/13

Multiplicación de Matrices con Pthreads, OpenMP y MPI

Roxana LuqueIngeniería en Informática

Facultad Politécnica

Universidad Nacional de AsunciónSan Lorenzo, Paraguay

[email protected]

Nelson MolinasIngeniería en Informática

Facultad Politécnica

Universidad Nacional de AsunciónSan Lorenzo, Paraguay

[email protected]

RESUMENEn este trabajo, se propone la implementación de algoritmos que

realizan la multiplicación paralela de matrices cuadradas

utilizando Pthreads, OpenMP y MPI. As mismo, se presentan

los resultados de algunas pruebas lle!adas a cabo para analizar

el rendimiento de cada algoritmo.

Palabras ClavesPthread, OpenMP, MPI, matrices.

1. INTRODUCCIÓNEn programas de cómputo num"rico es muy com#n

encontrar tareas que pueden ser realizadas en paralelo $%&. Para

estos casos resulta muy #til lanzar threads y as realizar el

procesamiento en paralelo. En particular, se analiza el caso de

un programa de multiplicación de matrices cuadradas en

lenguaje ' utilizando las libreras Pthread, OpenMP y MPI. (as

dos primeras libreras est)n basadas en el paradigma de

memoria compartida y la #ltima en el paso de mensajes.

(os algoritmos de matrices, y entre ellos los de

multiplicación de matrices, han encontrado numerosas

aplicaciones en la resolución de problemas tanto num"ricos,

como aquellos que no son num"ricos. (a *acilidad con que se puede particionar el problema de multiplicar dos matrices

cuadradas, lo con!ierten en un candidato ideal para estudiar los

conceptos de computación paralela, y permiten que sea *)cil

*ormular algoritmos que apro!echen los recursos de un entorno

paralelo.

El documento se di!ide en di!ersas secciones,

primeramente se da una bre!e introducción a las libreras, a

continuación una comparación entre ellas y por #ltimo los

resultados e+perimentales, conclusiones, re*erencias y como

ane+o los códigos *uentes.

2. PTHREADS(os hilos comparten un espacio de memoria com#n y con

*recuencia son programados scheduled- dentro de un solo

proceso, de *orma que se e!itan un montón de las ine*iciencias

de m#ltiples procesos $&.

(os hilos en un mismo proceso comparten/

• Instrucciones del proceso

• (a mayor parte de los datos

• Archi!os abiertos descriptores o 0descriptors1-

• 2e3ales y manejadores de se3ales 0signal handlers1-

• El directorio actual de trabajo

• I4 del usuario y del grupo

Pthreads es un conjunto de inter*aces para hilos desarrolladas

por el IEEE, que a cargo de la especi*icación de un sistema

operati!o portable Portable Operating 2ystem Inter*ace 5

PO2I6-. (a P en Pthreads signi*ica PO2I6 y, de hecho, en

ocasiones a Pthreads se le llama hilos PO2I6. En esencia, el

comit" PO2I6 de*ine un conjunto b)sico de *unciones yestructuras de datos que se espera que sea aprobado por los

numerosos !endedores para que el código de hilos pueda ser

portado *)cilmente a tra!"s de los sistemas operati!os. El sue3o

de la comisión *ue concebido por los !endors de 78I6 que en

su mayora implementaron Pthreads. (a e+cepción notable es

2un, que sigue pre*iriendo a los hilos 2olaris9 como su principal

API de hilos-. (a portabilidad de Pthreads se ha ampliado a#n

m)s por la adopción de (inu+ y un puerto para plata*ormas

:indo;s.

Pthread esta de*inido como un conjunto de tipos y llamados a

procedimientos del lenguaje ', implementado en el encabezado

del archi!o !a include con pthread.h, que es la librera que nos

pone a disposición todos los tipos y procedimientos para usar

hilos en un programa.

2.1 Implementac!n c"n Pt#rea$sPara realizar la implementación con Pthreads se modi*icó la

*unción que multiplica matrices para que recorra la primera

matriz desde y hasta unas *ilas pasadas como par)metro.

<ambi"n se tu!o que modi*icar el código que in!ocaba a esa

*unción para que cree los threads in!ocando para cada uno de

ellos a la *unción que realiza el producto con una parte distinta

de la matriz.

2e utilizó el 'ompilador gcc y la librera Pthreads de (inu+ para

compilar y ejecutar el programa.

%. OPENMP'on OpenMP $=&, los threads son distribuidos y ejecutados en

di*erentes procesadores, reduciendo el tiempo de ejecución

haciendo que m)s ciclos de procesos est"n disponibles por

unidad de tiempo. (os resultados de cada ejecución de threads

pueden luego ser combinados. 7n usuario puede establecer los

n#meros de threads creados para regiones paralelas.

OpenMP es una inter*az de programación de aplicaciones API-

para la programación multiproceso de memoria compartida en

m#ltiples plata*ormas. Permite a3adir concurrencia a los

mailto:[email protected]






programas escritos en ', '>> y ?ortran sobre la base del

modelo de ejecución *or@5join. Est) disponible en muchas

arquitecturas, incluidas las plata*ormas de 7ni+ y de Microso*t

:indo;s. 2e compone de un conjunto de directi!as de

compilador, rutinas de biblioteca, y !ariables de entorno que

in*luencian el comportamiento en tiempo de ejecución.

%.1 Implementac!n c"n OpenMPPara la implementación de la multiplicación de matrices con

OpenMP se propone una estrategia que consiste en asignar un

n#mero de *ilas de la primer matriz a cada thread para que cada

uno se encargue #nicamente de ellas.

Para hacer que OpenMP distribuya el programa de

multiplicación de matrices entre multiples threads solo hace

*alta agregar justo antes del código del ciclo principal de la

multiplicación una directi!a para que el compilador se encargue

de todo. Esto *acilita muchsimo la programación, ya que no hay

que modi*icar el código para que maneje los threads, sino que

toda la preocupación esta en programar bien el algoritmo,

dejando para OpenMP el trabajo de la creación y administración

de los threads.

2e utilizó el 'ompilador gcc y la librera OpenMP de (inu+

para compilar y ejecutar el programa.

&. MPIMPI no es un nue!o leguaje de programación, es una librera de

*unciones a la que podemos llamar desde ' ó ?ortran. Esta

basada en paso de mensajes, la *orma m)s potente y aceptada

para programar sistemas paralelos y permite abstraer la gran

cantidad de detalles que la programación paralela conlle!a. 2u

!entaja m)s inmediata es su implementación y portabilidad a

una gran !ariedad de sistemas/ desde m)quinas con memoria

compartida Origin- hasta una red de estaciones de trabajo

$B&.

Aunque e+isten otros en*oques de la programación en paralelodirecti!as de memoria compartida, como OpenMP-, el paso de

mensajes es considerado por algunos como el ensamblador de la

programación paralela, por el grado de acercamiento a la

estructura paralela de nuestro programa, manteni"ndonos a sal!o

de los problemas de implementación en cada tipo de m)quina.

Ejecutando un programa en MPI, cada procesador tiene una

copia de nuestro programa. <odos los procesadores comienzan a

ejecutar el mismo listado del programa, pero cada proceso

ejecutar) distintas sentencias del programa, por bi*urcaciones

introducidas basadas en el rango del proceso el rango identi*ica

a cada proceso-. 4e esta *orma, cada procesador ejecuta el

mismo programa, pero har) di*erentes cosas dependiendo del

procesador donde se ejecuta.

&.1 Implementac!n c"n MPIPara la implementación de multiplicación de matrices tenemos

un proceso maestro, el cual distribuye las distintas tareas al resto

de procesos y !arios procesos ;or@er quienes calculan un cierto

n#mero de *ilas de la matriz resultante y reen!a el resultado

parcial al proceso maestro.

2e utilizó el 'ompilador gcc y la librera MPI de (inu+ para

compilar y ejecutar el programa.

'. OPENMP (ERSUS PTHREAD(ERSUS MPI2e di*erencian principalmente en el comportamiento en el ni!el

de control que se quiere sobre la paralelización. OpenMP es

buensimo si todo lo que se necesita hacer es colocar algunas

directi!as Cpragma para tener una !ersión paralela de un código

serial r)pidamente. Ahora para realizar cosas m)s interesantescomo codi*icación de colas complejas, se puede utilizar

OpenMP pero sera m)s directa y *)cil la utilización de Pthreads

$D&.

OpenMP pro!ee caractersticas reducidas, es decir se consigue

muchas *uncionalidades con mucho menos trabajo.

OpenMP es mucho alto ni!el de Pthread. Es *)cil de usar, basta

con a3adir algunas directi!as. Por otro lado, Pthread le da m)s

control de su código y se puede aprender y entender lo que est)

sucediendo en un algoritmo paralelo.

(as directi!as Cpragma de OpenMP tienen otra !entaja cla!e/ se

puede deshabilitar el soporte para OpenMP, el código puede ser

compilado como una aplicación serial.

Ambas API son port)tiles, pero Pthreads o*rece una gamamucho mayor de *unciones primiti!as que proporcionan un

control m)s preciso sobre las operaciones de sobre hilos.

'abe mencionar que una de las !entajas de Pthreads sobre

OpenMP es que el programador tiene un mayor control sobre la

creación, destrucción y el comportamiento de los hilos, ya que la

gestión de un hilo est) en un ni!el m)s bajo en Pthreads que en

OpenMP.

En cuanto a MPI se puede decir que necesita que su proceso

maestro haga #nicamente un trabajo espec*ico. (a razón detr)s

de esto es reducir la sobrecarga en paralelo. Por lo tanto, el

proceso maestro puede centrarse sólo en la gestión y

distribución de datos.

A di*erencia de MPI en OpenMP y Pthreads, la gestión de

procesos y sincronización se realiza en la misma memoria esdecir memoria compartida- y no sólo el hilo principal sino todos

los hilos tambi"n son responsables de la sincronización de

subprocesos.

Algunas !entajas podran ser que con MPI es m)s *)cil de

entender cómo se distribuye los datos y cuanto tiempo se uso y

que tiene muchas de las herramientas disponibles para ayudar al

programador. (as des!entajas es que tiene una codi*icación

compleja de leer, escribir y mantener.

). RESU*TADOS E+PERIMENTA*ESEn la siguiente tabla se obser!a el entorno de ejecución utilizado

para realizar las pruebas.

2e implementaron tres aplicaciones en lenguaje ', siendo el

código *uente cada una de las siguientes/ pthreadmmult.c,

Pr"cesa$"r Mem"ra Dsc" D,r" S.O.

IntelF 'oreG iD5

M=H =J

44KH

L44 DJ7buntu

%%.D'P7 , Lz, HMJ

'ache rpm



ompmmult.c y mpimmult.cN con sus respecti!os ejecutables

pthreadmmult, ompmmult y mpimmult.

(as aplicaciones se encargan de calcular la multiplicación de

dos matrices cuadradas, la primera utiliza la librera pthread.h, la

segunda omp.h. y la tercera mpi.h para calcular el desempe3o de

la multiplicación utilizando estos tres en*oques.

2e ejecutaron las aplicaciones tomando como *actores ladimensión de la matriz y la cantidad de hilos a utilizar. (os

ni!eles para estos *actores son para dimensión de matriz/

DB+DB, D%+D%, %=+%=, =+=. para cantidad de

hilos/ , =, y %B. (as pruebas se ejecutaron probando cada

ni!el de dimensión de matriz con cada ni!el de cantidad de hilo.

Es decir, se ejecutaron las aplicaciones para una dimensión de

DB+DB con hilos, con = hilos, con hilos y con %B hilos.

Esto sucesi!amente por cada ni!el del *actor dimensión de

matriz. (a m"trica utilizada es el tiempo de respuesta. En las

<abla %, y HN se puede !er el resultado de estas pruebas.

Tabla 1.Temp" $e resp,esta para Pt#rea$

2 #l"s & #l"s - #l"s 1) #l"s

2') %=B B BD B='12 %% BB D D

12& HDB %D %BB %

2&- HHB %DH= %DHH %D=BQQ

2e puede !er que a medida que aumenta el tama3o de la matriz

aumenta el tiempo de respuesta. 'on relación a si la

paralelización a porta o no alg#n bene*icio, se podra !er que en

algunos casos se consigue un mejor tiempo, sin embargo como

las pruebas se realizaron en una maquina de un solo procesador

estos resultados no son concisos.

En la ?igura % se obser!a los !alores obtenidos en la tabla

anterior para los distintos tama3os de matrices y cantidades dehilos con Pthreads.

PTHREADS

1

10

100

1000

10000

100000

1000000

2 hilos 4 hilos 8 hilos 16 hilos

Nro. de Hilos

T i e m p o d e r e s p u e s t a

256

512

1024

2048

/0,ra 1. Temp" $e resp,esta en mlse0,n$"s paraPt#rea$s.

Obser!ando los resultados obtenidos con Pthreads se puede !er

que a medida que se incrementa el tama3o de las matrices

tambi"n aumenta el tiempo de ejecución, en donde se nota

mayor di*erencia es cuando se pasa de una matriz de tama3o D%

a una matriz de tama3o %=.

Tabla 2.Temp" $e resp,esta para OpenMP

2 #l"s & #l"s - #l"s 1) #l"s

2') %= B% H

'12 %=%= BB DDQ D

12& H%=H %DQH %==D %=H%

2&- H%DHH %B%% %DHB% %DBHBB

En la ?igura se obser!a los !alores obtenidos en la tabla

anterior para los distintos tama3os de matrices y cantidades de

hilos con OpenMP.

OPENMP

1

10

100

1000

10000

100000

1000000


Nro. de Hilos


256

512

1024

2048

/0,ra 2. Temp" $e resp,esta en mlse0,n$"s paraOpenMP.

Obser!ando los resultados obtenidos con OpenMP se puede !er

que son relati!amente parecidos a los obtenidos con Pthreads

por lo cual podemos decir que se comporta de manera similar en

cuanto a tiempo de respuesta.

Tabla %. Temp" $e resp,esta para MPI

2 #l"s & #l"s - #l"s 1) #l"s

2') = Q % =

'12 DHQ DBQ HQ%B BHB

12& %Q %%D%= %%H %HBDH

2&-

En la ?igura H se obser!a los !alores obtenidos en la tabla

anterior para los distintos tama3os de matrices y cantidades de

hilos con MPI.

MPI

1

10

100

1000

10000

100000

1000000


Nro. de Hilos


256

512

1024

2048

/0,ra %. Temp" $e resp,esta en mlse0,n$"s para MPI.



Obser!ando las tablas y los gr)*icos se puede !er que el tiempo

de ejecución de OpenMP y Pthread son pr)cticamente iguales

para un mismo tama3o de matriz, lo cual tiene sentido debido a

que se realizo el mismo particionamiento y adem)s OpenMP es

una capa que te abstrae de la necesidad de inicializar, crear,

liberar los hilos, sin embargo esta basado en Pthreads, en cuanto

a MPI podemos !er que los !alores de tiempo de ejecución son

m)s grandes que los obtenidos con OpenMP y Pthreads.

En las siguientes *iguras se muestra el tiempo de ejecución de

las aplicaciones implementadas en Pthreads, OpenMP y MPI

para una misma dimensión de la matriz.

Multiplicación de matrices de 25!25

0

50

100

150

200

250

300

2 4 8 16

"antidad de Hilos


Pthread

OpenMP

MPI

/0,ra &. Temp" $e resp,esta en mlse0,n$"s para lam,ltplcac!n $e ,na matr $e 2')2')

Para la ?igura =, se puede !er hubo una peque3a mejora con la

utilización de hilos de Pthread a OpenMP y una gran mejora

en MPI, sin embargo para y %B hubo un aumento grande de

tiempo de respuesta con MPI.

Multiplicación de matrices de 5#2!5#2

0

1000

2000

3000

4000

5000

6000

7000

2 4 8 16

"antidad de Hilos


Pthread

OpenMP

MPI

/0,ra '. Temp" $e resp,esta en mlse0,n$"s para la

m,ltplcac!n $e ,na matr $e '12'12

Para la ?igura D, de dimensión D%+D%, se puede !er que hubo

en todos los casos un gran aumento de tiempo de respuesta con

MPI para todas las cantidades de hilos, sin embargo para

Pthreads y OpenMP se obtu!ieron rendimientos similares.

Multiplicación de matrices de #$2%!#$2%

0

20000

4000060000

80000

100000

120000

140000

160000

2 4 8 16

"antidad de Hilos

T i e m p o

d e r e s p u e s t a

Pthread

OpenMP

MPI

/0,ra ). Temp" $e resp,esta en mlse0,n$"s para lam,ltplcac!n $e ,na matr $e 12&12&

Para la ?igura B, se puede !er hubo una peque3a mejora para las

distintas cantidades de hilos , =, y %B- de OpenMP con

respecto a Pthreads. As tambi"n se obser!a que con MPI se

obtiene mayor tiempo de respuesta que los anteriores.

Multiplicación de matrices de 2$%&!2$%&

0

50000

100000

150000

200000

250000

300000

350000

2 4 8 16

"antidad de Hilos


Pthread

OpenMP

MPI

/0,ra 3. Temp" $e resp,esta en mlse0,n$"s para lam,ltplcac!n $e ,na matr $e 2&-2&-

Para la ?igura , se puede !er hubo un peque3o incremento en

el tiempo de ejecución de OpenMP con respecto a Pthreads para

y = hilos, sin embargo seg#n se puede obser!ar para y %B

hilos ambos muestran un tiempo de respuesta casi igual. Rer la

#ltima *ila de las <ablas %, y H.

3. CONC*USIONES'omo se pudo obser!ar, la di*erencia en los tiempos obtenidos

por las implementaciones no *ue tan signi*icati!a, pero en la

mayora de los casos para este problema, Pthreads obtu!o

resultados ligeramente mejores que OpenMP, sin embargo hay

que resaltar que con MPI se obtu!ieron resultados de tiempo

muy ele!ados con respecto a los otros.

'omo las dimensiones de matrices aumentan, la di*erencia entre

el tiempo de ejecución tomada para el c)lculo de matrices con

OpenMP, P<hread y MPI aumenta signi*icati!amente. Adem)s

se puede !er que utilizando el mismo particionamiento en

OpenMP y Pthreads, estos tienen e+actamente el mismo

comportamiento teniendo as el mismo tiempo de ejecución.

OpenMP abstrae de las tareas habituales para el tratamiento de

hilos, lo que lo hace m)s *)cil de desarrollar, pero as tambi"n se



tiene menos control sobre los hilos. Es decir, si se necesita un

control *ino sobre la paralelización se utilizara Pthreads y si se

necesita paralelizar lo m)s r)pido posible, por ejemplo ya se

posee la aplicación serial, se utilizara OpenMP.

Si bien trabajar con Pthreads nos brinda mayor control respecto

de cómo asignar las partes de las matrices a cada thread, también

nos dificulta la tarea de paralelizar, teniendo que escribir mucho

código. Por otro lado OpenMP resuelve de manera simple latarea de paralelizar un código, haciendo que el programador

pueda concentrar sus energías en el algoritmo que esta

codificando y no en la creación y manipulación de threads.

-. RE/ERENCIAS$%& An Introduction to Parallel 'omputing. 2econd Edition.

Addison :esley

$& http/SS;;;.ibm.comSde!eloper;or@sSlinu+SlibrarySl5

posi+%Sinde+.html

$H& http/SSes.;[email protected];i@iSMultiplicaci

T'HTJHndematrices

$=& http/SSes.;[email protected];i@iSOpenMP

$D& http/SSso*t;are.intel.comSen5usSarticlesSthreading5models5

*or5high5per*ormance5computing5pthreads5or5openmpS

$B& 4. an Mey, 0Matri+ multiplication using mpi.1

4. ANE+O CÓDI5OS /UENTES

4.1 Implementac!n c"n Pt#rea$s/* ============================================================================

NOMBRE: pthread_mmult.c

AUTORES

Roxana u!ue " Nel#on Mol$na#

%ES&R'(&'ON

Mult$pl$cac$on de matr$ce# con (thread#

Un$)er#$dad Nac$onal de A#unc$on " acultad (ol$tecn$ca

&arrera: 'n+en$er$a 'n,ormat$ca

Mater$a: Elect$)a - " Al+or$tmo# (aralelo#

(ro,e#or: &hr$#t$an -on ucen

Anho: 012

============================================================================

*/

3$nclude 4pthread.h5

3$nclude 4#tdl$6.h5

3$nclude 4#td$o.h5

3$nclude 4#7#/t$me6.h5

$nt h$lo#89=;<9<<1>?@ //&ant$dad de h$lo#

$nt **A< **B< **&@

$nt TAM@

#truct re+$#tro;



$nt uno@

$nt do#@

?@

$nt **crearMatr$C ;

$nt $@ $nt *)alore#< **temp@

)alore# = $nt *C malloc TAM * TAM * #$eo,$ntCC@

temp = $nt **C malloc TAM * #$eo,$nt*CC@

,or$=0@ $ 4 TAM@ $DDC

temp8$ = )alore#8$ * TAMC@

return temp@

?

)o$d car+ar_matr$$nt **matr$< $nt TAMC

;

$nt $< F< n = 0@

,or $=0@ $4TAM@ $DDC

,or F=0@ F4TAM@ FDDC

matr$8$8F = $ntC randCG100@

?

)o$d* mmult )o$d* paramC;

#truct re+$#tro *m_param=#truct re+$#tro *Cparam@

$nt de#de = m_param"5uno * TAMC/m_param"5do#@

$nt ha#ta = m_param"5unoD1C * TAMC/m_param"5do#@

$nt $<F<@

,or $=de#de@ $4ha#ta@ $DDC

,or F=0@ F4TAM@ FDDC ;

&8$8F=0@

,or =0@ 4TAM@ DDC

&8$8F D= A8$8*B88F@

?

return 0@

?



$nt ma$n$nt ar+c< char *ar+)8C

;

pthread_t *thread@ // puntero a un +rupo de h$lo#

$nt $< F@

#truct t$me6 t_$n$< t_,$n@

$, ar+c H= C ;

pr$nt,IEFecutar: G# 4TAM5< donde TAM e# la d$men#$on de la matr$JnI<ar+)80C@

ex$t1C@

?

// de,$n$endo el tamanho de la matr$

TAM = ato$ar+)81C@

#truct re+$#tro *dato#=#truct re+$#tro *Cmalloc#$eo,#truct re+$#troCC@ pr$nt,I"""""""""""""""""""""""""""""""""""""""""JnIC@

pr$nt,IMult$pl$cac$on de matr$ce# de tamanho GdJnI<TAMC@

pr$nt,I"""""""""""""""""""""""""""""""""""""""""JnIC@

,or F=0@ F4=K@FDDC

;

A = crearMatr$C@

B = crearMatr$C@

& = crearMatr$C@

//&ar+ando la# matr$ce# con )alore#

car+ar_matr$A< TAMC@

car+ar_matr$B< TAMC@

)o$dC ,t$met_$n$C@

thread = pthread_t *C malloch$lo#8F * #$eo,pthread_tCC@

,or $=0@ $4h$lo#8F@ $DDC

;

dato#"5uno=$@

dato#"5do#=h$lo#8F@

$, pthread_create thread8$< NU< mmult< dato#C H= 0 C

;

perrorINo #e puede crear el h$loIC@

ex$t"1C@

?

?



// el h$lo pr$nc$pal e#pera por lo# otro# h$lo# para completar

,or $=0@ $4h$lo#8F@ $DDC

;

pthread_Fo$n thread8$< NUC@

?

)o$dC ,t$met_,$nC@

//t$empo de eFecuc$Ln

lon+ t_tot=t_,$n.t$meone*>0*1000Dt_,$n.t$me*1000Dt_,$n.m$ll$tmC"t_$n$.t$meone*>0*1000Dt_$n$.t$me*1000Dt_$n$.m$ll$tmC@

pr$nt,IJnJnIC@

pr$nt,IT$empo de re#pue#ta para Gd proce#o# e#: Gldm$l$#e+undo#.JnI<h$lo#8F< t_totC@

?

pr$nt,IJnIC@return 0@

?

4.2 Implementac!n c"n OpenMP

/*

============================================================================

NOMBRE: omp_mmult.c

AUTORES


%ES&R'(&'ON

Mult$pl$cac$on de matr$ce# con OpenM(





Anho: 012

============================================================================

*/3$nclude 4#td$o.h5

3$nclude 4#tdl$6.h5

3$nclude 4t$me.h5

3$nclude 4omp.h5

$nt h$lo#89=;<9<<1>?@ //&ant$dad de h$lo#

$nt **A< **B< **&@



$nt TAM@

$nt **crearMatr$C ;

$nt $@

$nt *)alore#< **temp@

)alore# = $nt *C malloc TAM * TAM * #$eo,$ntCC@

temp = $nt **C malloc TAM * #$eo,$nt*CC@

,or$=0@ $ 4 TAM@ $DDC

temp8$ = )alore#8$ * TAMC@

return temp@

?

)o$d car+ar_matr$$nt **matr$< $nt TAMC

;

$nt $< F< n = 0@



matr$8$8F = $ntC randCG100@

?


; $nt t$d< nthread#< $<F<< l@

dou6le $n$< ,$n@

$, ar+c H= C ;

pr$nt,IEFecutar: G# 4TAM5< donde TAM e# la d$men#$on de la matr$JnI<ar+)80C@

ex$t1C@

?

// de,$n$endo el tamanho de la matr$

TAM = ato$ar+)81C@

pr$nt,I"""""""""""""""""""""""""""""""""""""""""JnIC@


pr$nt,I"""""""""""""""""""""""""""""""""""""""""JnIC@

,or l=0@ l4=K@lDDC

;



3pra+ma omp parallel #haredA<B<&<nthread#C pr$)ate$<F<<t$dCnum_thread#h$lo#8lC

;

t$d = omp_+et_thread_numC@

$, t$d == 0C ;

nthread# = omp_+et_num_thread#C@

?

A = crearMatr$C@

B = crearMatr$C@

& = crearMatr$C@

//&ar+ando la# matr$ce# con )alore#

car+ar_matr$A< TAMC@

car+ar_matr$B< TAMC@

$, t$d == 0C

$n$ = omp_+et_t$meC@

//Mult$pl$cac$on

3pra+ma omp ,or #chedule#tat$c< TAM/h$lo#8lC


,or F=0@ F4TAM@ FDDC ;

&8$8F=0@

,or =0@ 4TAM@ DDC

&8$8F D= A8$8*B88F@

?

$, t$d == 0C ;

,$n = omp_+et_t$meC@

pr$nt,IJnJnIC@

pr$nt,I T$empo de re#pue#ta para Gd h$lo#: G,m$l$#e+undo#.JnI< h$lo#8l< ,$n"$n$C*1000C@

?

?

?

pr$nt,IJnIC@

return 0@

?

4.% Implementac!n c"n MPI

/*

============================================================================

NOMBRE: mp$_mmult.c



AUTOR


%ES&R'(&'ON

Mult$pl$cac$on de matr$ce# con M('





Anho: 012

============================================================================

*/

3$nclude 4mp$.h5

3$nclude 4#td$o.h5

3$nclude 4math.h5

3$nclude 4t$me.h5

3$nclude 4un$#td.h5

3$nclude 4#tdl$6.h5

3de,$ne TAM 2> /* Tamanho de la# matr$ce# */

$nt A8TAM8TAM< B8TAM8TAM< &8TAM8TAM@

/* Se car+a la matr$ con )alore# de#de 0 ha#ta TAM*TAM */

)o$d car+ar_matr$$nt m8TAM8TAMC;

#tat$c $nt n=0@

$nt $< F@



m8$8F = nDD@

?


;

$nt proc< nroproc< $< F< < #um = 0@

dou6le t_$n$=0< t_,$n=0@

M('_Statu# #tatu#@

M('_'n$t ar+c< ar+)C@

/* Numero de proce#o# !ue pertenecen al comun$cador */



M('_&omm_#$eM('_&OMM_OR%< nroprocC@

/* Se e#ta6lece el $dent$,$cador del proce#o llamador en el comun$cador */

M('_&omm_ranM('_&OMM_OR%< procC@

/* El proce#o mae#tro car+a la# matr$ce# A 7 B */

$, proc==0C ;pr$nt,I"""""""""""""""""""""""""""""""""""""""""JnIC@


pr$nt,I"""""""""""""""""""""""""""""""""""""""""JnIC@

car+ar_matr$AC@

car+ar_matr$BC@

?

M('_Barr$erM('_&OMM_OR%C@

$, proc==0C ;

t_$n$ = M('_t$meC@

?

/* M('_Scatter en)$a parte# d$,erente# de A del proce#o ,uente< a cada proce#o$nclu7endo#e el m$#mo */

M('_Scatter A< TAM*TAM/nroproc< M('_'NT< A< TAM*TAM/nroproc< M('_'NT< 0<M('_&OMM_OR%C@

/* M('_Bca#t en)$a B del proce#o mae#tro a todo# lo# proce#o# */

M('_Bca#t B< TAM*TAM< M('_'NT< 0< M('_&OMM_OR%C@

/* Se real$a el computo local en cada proce#o */

,or $ = 0@$4nroproc@ $DDC

;

$, proc == $C

;

,or $ = proc*TAM/nroprocC@ $ 4 proc*TAM/nroprocCDTAM/nroprocCC@ $DDC

;

,or F = proc*TAM/nroprocC@ F 4 proc*TAM/nroprocCDTAM/nroprocCC@ FDDC

;

,or = proc*TAM@ 4 proc*TAMDTAM@ DDC

;

#um = #um D A8$8 * B88F@

?

&8$8F = #um@

#um = 0@

?



?

?

?

M('_ather &< TAM*TAM/nroproc< M('_'NT< &< TAM*TAM/nroproc< M('_'NT< 0<M('_&OMM_OR%C@

/* El proce#o mae#tro de)uel)e el t$empo de eFecuc$on*/

$, proc==0C ;

t_,$n = M('_t$meC@

pr$nt, IJnIC@

pr$nt,IT$empo de re#pue#ta para Gd h$lo#: G, m$l$#e+undo#.JnI< nroproc<t_,$n"t_$n$C*1000C@

pr$nt, IJnIC@

?

/* Real$a tarea# de l$mp$ea para ,$nal$ar el entorno de eFecuc$on */M('_$nal$eC@

return 0@

?

e5 pthread openmp mpi molinas luque

Documents