Discussion :

[uriotcea]

Bonjour,

J'observe quelquechose de tres etrange avec openMP
- Je calcul de temp necessaire pour une boucle de calcul
- Ensuite je fais exactement la même chose mais avec une directive openMP du style "#pragma omp parallele for" pour 2 processeurs
- j'en déduis que en dessous de 1000 iterations (n), paralléliser cette boucle n'est plus pertinant.
example : (t1:sans threading, t2:avec 2 cores)

n=100000 t1=10s , t2 =5s
n=10000 t1=1s, t2=0.8s
n=1000 t1=0.1s, t2=0.1s
n=100 t1=0.01s t2=0.03s


- J'ajoute une condition "if(n<1000)" dans ma directive et là commence les problemes. Si n est inferieur à 1000, le calcul n'est effectivement plus parallélisé (j'ai verifié) , mais les temps de calcul correspondent aux t2 et non au t1 comme je m'attendais. J'ai l'impression que le temps de gestion de la directive est toujours le même, "if" ou pas "if". Mais alors à quoi bon cette directive "IF". Ou ai-je oublié quelquechose ?

Merci de vos suggestions

[koala01]

Salut,

Le problème, c'est que, visiblement, n n'est connu qu'à l'exécution, alors que le pragma va agir... dés la compilation...

Il faut, en effet, se rappeler que les directives préprocesseur (#include, #ifdef / #ifndef, #pragma,...) sont prises en compte avant même que la première ligne de code assembleur ne soit créée... et donc, ne peuvent agir que... sur les constantes connues à la compilation...

Je vois donc deux solutions possibles, dont, il faut bien l'avouer, aucune n'est vraiment idéale:

1. Soit, tu définis le nombre d'itération à la compilation (en passant -DITERATION=nombrediteration (syntaxe Gcc) ), mais cela t'obligera à compiler ton application chaque fois que le nombre d'itérations changera,
2. Soit, tu crées deux applications distinctes:
   
   1. une application non parallèle à utiliser lorsque iteration < 1000
   2. une application utilisant le paralélisme à utiliser quand iteration > 1000
   mais tu auras alors le problème que l'utilisateur doit être considéré comme un imbécile distrait, et qu'il faut t'attendre à ce qu'il y en ait au moins un qui tente un jour d'utiliser une version alors qu'il devrait utiliser l'autre...

Tu vois, que, comme je l'ai dit plus haut, aucune des solutions n'est vraiment idéale...

Mais elles sont données "à chaud" et sans avoir réfléchi beaucoup plus que cela au problème, et il n'est pas impossible qu'il existe une troisième solution qui soit meilleure que ces deux ci

[uriotcea]

Merci de ta reponse, mais je pense que tu fais erreur. Je ne sais pas comment la directive du "IF" est interpretée, mais c'est bien dynamique, parce que le nombre de threads associé à mon application depend bien de la valeur de n. Je le verifie bien avec la charge de mes processeurs, le nbr de threads de l'appli ou même la commande "omp_get_num_threads()"

[screetch]

lorsque tu utilises openMP il y a toujours un surcout lié au découpage en tâches, dispatching des taches, etc
et ce, meme si il n'y a qu'un seul thread de travail (bouh! )
ce que tu peux faire, c'est dynamiquement faire un

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
if(n>1000)
{
  #pragma omp parallel for
}
else
{
  // code tout con qui ne va pas etre ralentit par openMP
}

[uriotcea]

Je pensais qu'avec un if(0) il n'y avait aucun decoupage, et que le code etait executé séquenciellement.
Maintenant ce que tu suggere et de dupliquer tout le code parallélisable.
C'est un peu lourd non

[koala01]

Je pensais qu'avec un if(0) il n'y avait aucun decoupage, et que le code etait executé séquenciellement.
Maintenant ce que tu suggere et de dupliquer tout le code parallélisable.
C'est un peu lourd non

Au pire, déporte (en fait, le terme correct est tu "factorise") le vers une fonction inline:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
inline void privateFunction(/* argument */)
{
    /* le code à dupliquer */
}
 
void foo()
{
    if(iteration >1000)
    {
         #pragma omp parallel for
         privateFunction(/* arguments éventuels */);
    }
    else
    {
         privateFunction(/* arguments éventuels */);
    }
}

Nota: inline n'oblige absolument pas le compilateur à inliner la fonction...

Mais, au pire, si tu t'arranges pour que la fonction ne soit appelée qu'une fois (AKA: que la boucle soit dans cette fonction "privée" et non dans la fonction appelante), la perte due à l'appel de fonction sera minime

[uriotcea]

La directive "#pragma omp parallel for" ne peut précéder qu'une instruction "for" !