EDIT : Pour ceux qui cherchent comment marchent les threads de Boost => http://www.ddj.com/cpp/184401518

Bonjour,

j'ai fait un programme en C++ qui génère plein de configurations de points qui respectent des potentiels donnés (en gros) mais comme je ne suis que physicien et que je code avec mes pieds, mon prog met a peu près 3j a s'exécuter  
Donc je me dis qu'un peu de parallélisation pourrait lui faire du bien mais je n'ai jamais fait ca. La question que je me pose est donc : quelle bibliothèque utiliser pour faire ca??? J'aimerai quelque chose de simple a mettre en œuvre et si possible portable (je code sous winXP mais le serveur sur lequel je veux le lancer au final tourne avec Unix).

Donc voila, j'aimerai avoir votre avis

Merci d'avance

Si t'es un scientifique, peut être faudrait-il argumenter ta théorie comme quoi la parallélisation améliorerait tes performances...
 
Utilise un profiler pour trouver ce qui est lent. Ensuite, c'est possible de réfléchir à comment améliorer les performances.
 
Paralléliser des calculs scientifiques, c'est très difficile à cause de problèmes de dépendances (alpha, beta, etc) et y a beaucoup de théorie derrière pour bien réussir ce changement.

Oui j'y ai un peu réfléchi et comme pour chaque potentiel testé je génère 5 configurations, je pensai simplement faire 5 threads qui génèrent chacun une configuration ... après le traitement des configurations est assez court donc je peux le laisser comme ca sans problème.
Je pense que ca peut marcher comme ca car pour générer une config il suffit de lire quelques variables pour connaitre l'état initial et le potentiel a tester et ensuite il n'y a aucun conflit en écriture car tout est indépendant. Donc je pense que c'est assez simple a faire quand on connait dans ce cas là .... mais manque de pot je ne connais pas

c'est du Number Crunching quoi,

pour de strheads portables : BOOST::Thread

lance plusieurs fois ton programme ?

Heuuu .... peut-etre  
Je suis déjà tombé sur boost au fil de mes recherches et ca avait l'air pas mal ... si tu as un lien avec un joli tuto ou une jolie doc je suis preneur

Merci bien

Je suis pas sur que ce soit la meilleure solution
Parce que le truc c est que je génère mes 5 config, ensuite je les test par rapport à une config de référence et si elles conviennent j'en déduis que ce potentiel est "bon". Mais si il n'est pas bon je le modifie et je recommence. Donc je préfère que ce soit automatique plutôt que lancer le prog plusieurs fois puis lancer un autre prog pour tester les config puis modifier le potentiel, etc ....

un script Shell / Python / Autre peut faire office de "glue" :x

http://boost.org/doc/html/thread.html
 
Pour les exemples, telecharge boost et regarde dans le repertoire sample. Si tu as du mal demande

J'en reviens quand même au "je code avec mes pieds" : se lancer dans les threads quand on y connaît moins que rien ce n'est pas forcément la première des solutions alors qu'il y a certainement des optimisations juteuses à faire

Merci Joel
 
Taz => il me semble déjà avoir optimisé pas mal de chose simplement au niveau de l'algorithme ... et vu le mécanisme du programme les threads apporteraient vraiment quelque chose. Et puis j'ai les pieds habiles ^__^
Enfin bref je vais essayer .... et puis si j'y arrive pas je vous demanderai
 
Merci à tous

On n'a que trop vu de gens bien intentionnés implémenter un algo N^2 en N^3...

 
c'est a dire?

http://fr.wikipedia.org/wiki/Compl [...] orithmique
 
un algo "complexe"  koa ^^
 

ah ok
Donc qui du coup serait encore plus long a s'exécuter parce que les threads sont mal fichus?
Ben je vais essayer de ne pas tomber dans le piège

c'est indépendant des threads :x

Ca n'a rien a voir avec les threads. C'est une majoration du nombre d'operations en fonction de certaines donnees d'entree.  
Ce que veut te dire Taz c'est que tres souvent il suffit de modifier l'algorithme pour gagner carrement un ordre de grandeur en temps d'execution. Ca ne sert a rien de paralleliser un algorithme dont la complexite est en N^2.

ouais sauf si c'est l'algo optimal pour le problème quoi

... et qu'on connait deja la taille du probleme a traiter ... car dans l'absolu ca n'a pas de sens de chercher a diviser par une constante un truc quadratique...

Je suis pas sur de comprendre ce que vous racontez mais bon
Bref, honnêtement je pense que l'algo est déjà pas trop mal optimisé dans sa version séquentielle et que vu que je fais 5 fois la même chose a chaque itération je pense que la parallélisation est plus que pertinente
 
En tout cas il me semble avoir trouvé (attention les yeux, je doute que ce soit très propre ).... j'appelle la fonction (qui elle même appelle la fameuse fonction que je fais 5 fois par itération)
 
void appel_metro1(const vector<commerce2> config_occupation_init,vector<commerce> config1,const vector<commerce> coo,const vector<commerce> config_init,const long double potentiel[],const int iter,long double grconfig1[]){
    metropolis(coo,config_init,config_occupation_init,potentiel,iter,config1,grconfig1);
}
 
avec  
 
 
        boost::thread_group threads;
        threads.create_thread(boost::bind(&appel_metro1,config_occupation_init,config1,coo,config_init,potentiel,iter,grconfig1));
.
.
(je l'appelle autant de fois que j'en ai besoin)
.
.
threads.join_all();
 
et hop
En tout cas ca compile et ca se lance ... je dois juste vérifier que les résultats sont cohérents
 
Merci beaucoup a vous pour votre aide

Question debile : c'est quoi la machine sur laquelle ton programme va tourner au final ?

un serveur du CNRS

a moi pour une question débile
Quand j'appelle ma fonction metropolis comme je l'ai fait, les variables locales de cette fonction sont bien clairement séparées pour chaque thread ou non?

Tant que tu ne passe ni pointeur, ni références, les variables sont dupliquées. Aucun problème pour le thread donc.

ok merci

l'algo peut-être, l'implémentation...

en caricaturant:

 
une mauvaise implé avec de mauvaises structures de données, c'est vite fait de tout péter. Genre tu as un liste et tu n'arrêtes pas d'ajouter en fin, etc

Hello !
 
Bon tout marche nickel alors je vous reremercie encore
Et j'ai une dernière petite question : comment on peut faire pour que les cout<<..... que j'ai dans la fonction appelée par mes threads restent dans le bon ordre? Ca ne me dérange pas pour ce programme là parce que de toute façon j'ai juste besoin d'écrire le résultat final dans un fichier ... mais c'est par curiosité.

dans le bon ordre ? :x
cout fait par tes threads ? ^^

oui j'ai des cout dans les threads pour surveiller un peu ce qu'il fabrique ... ca allait bien quand je faisais qu'une chose a la fois mais là 5 d'un coup ca affiche un peu n'importe quoi
Enfin ca reste compréhensible mais c'est moche.
Donc bref je me posai la question
Mais la réponse est peut être simplement : pas de cout dans les threads? Ca paraitrait logique d'ailleurs ^^

ah et au fait un truc beaucoup plus embêtant .... comment je compile ce truc sur Unix ?
J'utilise la commande g++ d'habitude mais là il faudrait que je lui dise ou est boost (ce que je ne sais pas encore d'ailleurs) et je sais pas faire. Si quelqu'un connait ca ...

-I/usr/include... -L/usr/lib/... -lboost_...

Ok j'essairai ca
 
Merci beaucoup!