Comparaison entre la commande DO et la commande FORALL avec OPENMP

Bonjour,

j'ai utilisé la commande FORALL et la COMMANDE DO avec ou sans OPEM MP et j'ai obtenu
certains résultats sur le temps d'execution que j'aimerai vous partager car j'ai quelques
points d'interrogation ...

===========================================================
Matos et logiciels utilisés
===========================================================
Microsoft Windows XP Professional x64 Edition (version 2003) Service Pack 2

double Intel Xeon E5540 2.53GHz 24 Go (2x4 coeurs)
Hyperthreading déactivé (8 coeurs).

Cygwin 1.7.5

MINGWIN GCC pour windows 64Bits (pour visibilité de la mémoire > 3.2 Go)

gfortran -v
target x86_64-w64-mingw32.
Thread model win32
GCC version 4.4.5 20100513 (prerelease) [svn/rev.159365 - mingw-w64/oz].


===========================================================
Programe faisant des calculs sur plusieurs tableaux ( :,:,: ) occupant environ 13 Go
===========================================================

===========================================================
Sans Openmp ..........................sans opt..............................-O3
===========================================================
Triple DO...............................2min 21 s.........................1min 5 s...........1 core utilisé
ForALL(x=,y=,z=)............................31 s..............................12 s..........1 core utilisé
===========================================================
gfortran -lm -O3 non.f95 -o non.exe
===========================================================



===========================================================
Avec Openmp ..........................sans opt..............................-O3
===========================================================
Triple DO......................................... 25 s .............................15 s..........8 cores utilisés
FORALL(x=,y=,z=) ............................1m9 s............................ 12 s..........1 core utilisé
===========================================================
gfortran -lm -fopenmp -O3 non.f95 -o non.exe
===========================================================
!$OMP PARALLEL DO PRIVATE(x,y,z) SHARED(...) ! Pour (DO x=) (DO y=) DO(z=)
!$OMP PARALLEL WORKSHARE ! pour FORALL(x=,y=,z=)
===========================================================


Je constate que la commande FORALL est plus performante même sur 1 core. Par ailleurs,
je ne comprends pas pourquoi elle n'utilise qu'1 seul core. Est dû au fait qu'elle soit
déjà parallel (parcours dans n'importe quel ordre choisi par le processeur) ?

Est-ce que je n'ai pas omis une commande de compil ?

Bref je n'ai pas tout compris :-)


Ma question est la suivante : est-ce la fonction FORALL peut être parrallelisable
sur plusieurs cores avec OPENMP? si oui avec quelle version de Gfortran et quelle
version d'openmp ?



Merci d'avance.

Stéphane.

si mes souvenir sont bons, forall est difficilement parallélisable car à la différence de Do où le programmeur donne explicitement le sens de parcours (incrémental) dans un bloc forall, c'est le compilo qui détermine dans quel ordre il doit parcourir les valeurs...
de plus pour tes mesures de temps, il faut bien faire plusieurs éssai, et sur des tests un peu plus long genre 5min... pour bien saisir les différences...
cela dit forall doit pouvoir être paralléliser, attention il a peut-être des différences entre windows et linux là dessus (et je pense que c'est plus facile sous linux qui n'utilise pas du tout la même méthode de répartition de charge de calcul) même si tu utilise gcc sur chaque os...

genteur slayer

Merci pour ta réponse.

C'est bien ce que je pensais avec la commande forall. D'ailleurs je pense qu'il va être difficile de la faire tourner sous plusieurs cores (1 thread par core).

C'est peut-être possible mais à mon avis ça va dépendre du type de compilo et aussi de la version de celui-ci.


J'ai refait des tests sur 7 tableaux de taille ( 1:1000 , 1:500 , 1:500 ) en double precision. Taille occupant environ 13 Go.

J'ai executé 100 fois des triples boucle DO et FORALL sur ces volumes en y faisant des séries de calculs.

gfortran -lm -O3 -fopenmp nom.f95 nm.exe

FORALL : 3 min 33 s (sans openmp)
4 min 30 s (avec openmp)

DO : 15 m 14 s (avec openmp)

J'ai refait plusieurs fois le test et les résultats ne changent presque pas.

Conclusion: la boucle forall est plus appropriée à mon problème et ce quelques soient les parrallélisation sur la commande DO

Dernière question:

Tu m'as parlé de l'os utilisé avec gcc. Ne penses-tu pas, qu'avec gygwin qui est une sorte de plateforme linux tourant sous windows, l'excutable donné avec GCC va faire des calculs en utilisant la même méthode de répartition de charge de calcul comme sous linux ?

Je ne suis pas informaticien alors il y'a beaucoups de choses qui m'échappent.

Merci d'avance.

Stéphane

non, en fait cygwin n'est qu'un émulateur de linux! ce qui fait que pour beaucoup de choses il va se comporter de la même manière, c'est vrai. cependant, pour les utilisation de threads, même si il va te les 'présenter' comme le ferai un linux, il utilise tout de même les fonctions de windows...

de plus fait attention, cygwin n'existe pas (pas encore, mais on espère) en version 64bits et donc même avec un windows 64bits, un exécutable généré avec le gcc de cygwin sera 32bits.

chez moi, j'utilise un compilo 64 (le gcc de mingw) mais il est lancer depuis cygwin, qui ne joue alors le rôle seulement d'interpréteur de script...

de plus il me semble (la dernière fois que j'ai essayer de compiler un gcc remonte un peu) que la manière de traiter les threads est une option de compilation de gcc...

En théorie, il est beaucoup plus facile de paralléliser forall que do. forall a d'ailleurs été introduite pour faire converger Fortran 90 et High Performance Fortran dans Fortran 95.

Ce que j'ai compris (ou retenu) des discussions du forum comp.lang.fortran (Unenet ou via Google Group), c'est qu'il y a peu de demande pour optimiser forall alors qu'il y en a beaucoup pour l'optimisation de do. Il n'est donc pas surprenant que l'équipe de gfortran n'ait pas (encore) programmé la parallélisation du forall. Ça ne veut évidemment pas dire que si tu utilises un autre compilateur, la commande ne sera pas parallélisée non plus (mettons que je m'attendrais à ce que Cray ou Intel l'aient fait).

genteur slayer

Merci pour ta réponse.

J'utilise comme toi le compilo le gcc de mingw en 64bits lancé sous cygwin car ce dernier étant en 32 bits, il ne voyait pas toute ma mémoire qui est de 24 go (limite 3go du 32 bits). Avec le compilo de mingw en 64bits, je peux y acceder.

Bref je vais installer une gentoo 64 bits et on verra bien la différence ...


Merci Sylvain Bergeron pour les infos.

J'avais fait ma thèse en fortran77 (les autres versions 90/95 étaient payantes à l'époque) et je l'avais laissé tombé pour le C pour son allocation dynamique. Ca fait 2 mois que je me suis mis au fortran 95/2003 (2003 pour l'interopérabilité entre le fortran et le C).

Pour la commande FORALL qui fonctionne sur 1 core (avec -O3), je la trouve (pour ce que j'en fait: triple boucles incluant des commandes basiques de calcul) beaucoup plus puissance que la commande DO (même parallélisée avec openmp sur 8 cores ).

Je comprends mieux les programmeurs de gfortran qui n'ont je pense qu'introduit pour l'instant la commande WHERE (je pensais que ca devait être aussi implémenté pour FORALL vu que c'est le même procédé de parallélisation)

gfortran 4.5:

"Array assignments and in WHERE is now run in parallel when OpenMP's WORKSHARE is used."

rien pour la commande FORALL ...

Ma version : gfortran -v
target x86_64-w64-mingw32.
Thread model win32
GCC version 4.4.5 20100513 (prerelease) [svn/rev.159365 - mingw-w64/oz].

Je n'ai pas trouvé gfortran 4.6 ni la 4.5 pour mingw ... (ni pour gygwin d'ailleurs)

Donc à priori, pour ma version, la commande openmp version 3.0 est prise en compte mais pas les commande WHERE et FORALL bien que la commande !$OMP PARALLEL WORKSHARE est reconnue mais pas prise en compte durant l'execution.


Merci pour l'aide que vous m'avez apportée.

Stéphane.

dans ton gfortran -v:
Thread model win32

si tu télécharge les source de gcc, c'est une option du ./configure que tu peux faire varié mais je ne sais plus si pour la version mingw tu peux prendre autre chose (posix par exemple) cela dit, si tu passe sous linux, là tu aura le choix (à la compilation de gcc) du modèle de thread. cependant, je ne connais pas les avantages et inconvénients de chacune des méthodes: j'ai toujours gardé celle par défaut...
enfin, il est important de savoir lorsqu'on fait du calcul parallel:
utilisation d'un seul core cpu sous windows: 100/Ncore %
utilisation d'un seul core cpu sous linux: 100 %

donc sous linux si tu utilise deux core à fond tu dois avoir une utilisation de 200%...
mais c'est juste une manière de présenter, cela n'influ pas sur le temps de calcul ;)