Discussion :

[dhoorens]

Bonjour

Tout est presque dans le titre, cependant je vais un peu etayer ma demande.
J'aimerais lancer un projet au boulot qui consisterais en le calcul de certaines choses à travers pas mal de simulations.
J'aurais qqch du style

Code :

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

1
2
3
for (uint i = 1; i< simulationMAX; i++){
//... très long code fct (i) avec indépendance entre fct(i) et fct (j) pour tout //i<>j
}

A priori simulationMAX vaut minimum 1.000 et pourrait aller jusque 10.000
Pour le moment si je fais tourner ce genre de boucle sur un CPU j'en ai pour 15000 minutes ( ce qui est quand meme un peu long :-)

J'ai à ma disposition ma propre machine (2 CPU) et les machines de mes collègues sur lesquels j'ai droit d'admin => je pourrais avoir en terme de droit d'administration accès à 7 machines (=>14 CPU), mais je pourrais tenter d'avoir accès à 25 machines supplémentaires (=> 50 CPU) mais sur lesquels je n'ai pas de droit d'admin.
Ce que j'entends par droit d'admin est défini par la sécurité de la boite et me donne accès à tous les répertoires et je peux installer ce que je veux.
Si je n'ai pas de droit d'admin, j'ai accès à certain s folders mais pas aux reperoires système par exemple. Cependant si le projet fonctionne il serait envisageable d'ouvrir un peu plus les PC..

J'ai vu comment utiliser OpenMP. Ca fonctionne (heuruesement :-) ) sur ma machine, mais je ne sais pas s'il est possible d'utiliser cela au dela de ma machine mais sur d'autres machines aussi.
Si oui, comment? Faut il installer qqch sur els autres machines? Faut il modifier le code? Comment accède-t-on aux autres CPU?

Quels sont les problèmes au niveau de la sécurité reseau (Si la sécurité ouvre l'accès entre ma machine et les 25 mahcines..)?
D'autres expériences?

Merci
D

[3DArchi]

Salut,
A priori, OpenMP c'est sur la même machine. Pour massivement paralléliser tes simulations tu as plusieurs options :
-> CUDA ou tout autre environnement de GPGPU, mais ça reste sur la même machine.
-> Sur différentes machines, il faudrait peut être regardé ce qui est grille et des framework pour construire des applis distribuées.

[dhoorens]

A propos (pour moi et peut -être pour d'autres), voici un lien sympa sur openMP
http://msdn.microsoft.com/en-us/magazine/cc163717.aspx

[3DArchi]

Il y aussi des tutoriels OpenMP proposés sur DVP.

[epsilon68]

il faut faire du client server...

donc les machines de tes collegues sont les clients,
et tu es le server...
bon coucou les sockets etc

mais ce que je pense c'est qu'il serait peut-etre bien d'explorer la voie "database" comme centralisateur

toi tu mets les taches dans une DB (les 1000 simulations)
les clients verifient la db si il y a des taches puis les executent.

les clients devront appeler une stored procedure pour leur attribuer le numero d'une simulation non encore faite, attention a l'acces concurentiel...

ca sera peut-etre moins rapide que les sockets, mais tu pourras verifier les calculs apres coup. mais par contre ce qui est pas top, c'est la pompe a message....

remarque maintenant que j'y pense, il y a aussi l'option DCOM avec windows... en .NET pour eviter les longues parties de code pour rien...
avec DCOM, tu peux instancier un objet sur une certaine machine, et il fera le marshalling des argument pour toi... c'est pas mal.

donc pour resumer:

1. client server classique avec sockets
2. DCOM mais que sur Windows avec .NET
3. database + client pompe a message...

vos avis?


EDIT
c'est interessant comme probleme ... ca me donne envie de coder :-D

[Mac LAK]

Le problème de la parallélisation au niveau machine (= utiliser tous les CPU/coeurs disponibles) et celui de la distribution (= utiliser plusieurs machines) sont relativement différents.

Pour le premier, tu as le choix entre des frameworks tout prêts type OpenMP, ou du parallélisme "manuel". Dans les deux cas, cela n'a pas beaucoup d'importance car ce n'est pas excessivement complexe dans ton cas : en effet, tu as besoin de threads de travail autonomes, et non pas d'interactions complexes entre threads tournant continuellement. Tu es dans le cas le plus simple.

Dans le cas de la distribution, il faut voir des paramètres cruciaux :

• Taille des données source,
• Taille des résultats,
• Temps de calcul UNITAIRE sur ces données.

Typiquement, et pour volontairement exagérer, plus la taille totale des données (source + résultat) est "volumineuse" et le temps de calcul "petit", moins la distribution est intéressante / rentable. Inversement, de très petites données pour un temps CPU important est très intéressant pour la distribution.

Si c'est bien le cas, alors la distribution est rentable. Sinon, elle ne l'est pas, et seule l'utilisation de plusieurs CPU (ayant déjà un accès direct aux données) sera rentable pour accélérer ton traitement.

Une erreur courante en parallélisme est de penser que paralléliser un traitement fait gagner du temps machine. C'est faux : cela fait gagner du temps physique (=celui de ta montre), mais cela augmente toujours la charge CPU (=le temps CPU passé à réaliser l'action, inclus chaque coeur et la charge de transfert réseau des données).

Donc, si le temps supplémentaire nécessaire au lancement d'une deuxième unité d'exécution est supérieur au temps de calcul, la parallélisation n'est pas rentable.


Pour les solutions envisageable afin de distribuer ton calcul, la première chose à connaître sont les trois paramètres précités : taille des données source, des données résultat et temps de traitement pour cette unité "atomique" de calcul.
Mais il est tout à fait possible de rendre le processus complètement transparent pour le processus maître, qui se contentera de lancer 10.000 threads qui feront soit le calcul en local, soit en le distribuant en fonction de la charge de la machine, c'est même relativement simple d'ailleurs.

[dhoorens]

Dans le cas de la distribution, il faut voir des paramètres cruciaux :

• Taille des données source,
• Taille des résultats,
• Temps de calcul UNITAIRE sur ces données.

*En ce qui concerne les données source: je donne la taille en octets. Il s'agit d'un ensemble de tables qui peuvent être communes à toutes les simulations ou alors de paramètres spécifiques par simulation. Dans le premier cas, ca tourne aux aloentours de ~15 Mb, par contre les tables relatives aux simulations sont de l'ordre de 120 Mb => 120k par simulation

En ce qui concerne la taille des résultats, j'ai envie de dire que ca dépend...
Ca dépend pcq l'utilisateur peut avoir envie d'afficher beaucoup de résultats ou peu de résultats. Comme il s'agit d'un modèle avec pas mal de variables intermédiaires, il est possible de vouloir avoir en output par simulation je dirais de 50 à 1000 variables => ca depend...
Généralement on va plutot utiliser 50 variables . Je dois juste rajouter pour corser le tout qu'il s'agit d'un modèle dynamique => fct du temps => quand je dis 50 variables par simulation, ca désigne l'output de 50 variables par simulation ET par pas de temps =>50 var * 1000 * 500 pas de temps (héhé) => 25 Moutputs (vive les nouvelles unités :-)

En ce qui concerne le temps de calcul unitaire, que veux tu exactement dire?

Tks
D

[3DArchi]

En ce qui concerne le temps de calcul unitaire, que veux tu exactement dire?

Quel est le temps de la simulation ? L'idée est de savoir ce qui prend le plus de temps : attendre et dérouler les simus sur la même machine ou distribuer ces calculs sur différentes machines en prenant en compte :
1/ le temps d'échange de données
2/ les nécessités de synchronisation des données, des résultats et des simus (barrières)
3/ le mécanisme de lancement d'une simulation sur une autre machine.
Si les traitements sont nombreux mais très courts, en général, tu perds plus de temps à mettre un mécanisme de distribution du calcul que le bénéfice de l'exécuter en // sur différentes unités.

[dhoorens]

Ben le temps d'une simulation est de l'ordre du quart d'heure

[dhoorens]

En fait pour être un peu plus précis, nous disposons a l'heure actuelle d'un logiciel permettant de faire ce genre de simulations (calcul de plusieurs simulations sur plusieurs CPU et plusieurs machines), mais il est cher et pas pratique et surtout peu flexible pour ce qu'on doit faire avec=> les données que je donne sont celles qui correspondent à ce logiciel.
J'aimerais refaire un logiciel plus flexible et plus pratique => mais je ne connais pas encore (évidemment) le temps de run, mais j'imagine que ca devrait tourner dans le meme genre d'ordre de grandeur..

[Mac LAK]

Diffuser 120 ko pour 15 minutes de temps de calcul, c'est rentable en soi. Par contre, diffuser 15 Mo "communs" N fois pour le même temps, il serait étonnant que ça le soit, à moins d'utiliser un protocole de transfert en diffusion (ce qui est en soi quasiment un projet à part entière).

Dans ton message originel, tu écris :

Code :

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

1
2
3
for (uint i = 1; i< simulationMAX; i++){
//... très long code fct (i) avec indépendance entre fct(i) et fct (j) pour tout //i<>j
}

Ce que je veux savoir, c'est le temps pris par le "//... très long code indépendant", et surtout, la taille des données i appliquées à fct, ainsi que la taille des données retournées par fct(i).
De plus, le calcul entre l'étape i et i+1 est peut-être indépendant, mais qu'en est-il des données sources ? Est-ce que ce sont les mêmes, ou sont-elles indépendantes elles-aussi ? Même question pour les résultats.

En fonction de ces paramètres, on pourra t'aider à savoir si la distribution est rentable ou non.

Si tu veux des exemples concrets :

• Distribuer un calcul simple (disons un seuillage) sur une image haute résolution (>=1600x1200x32 bits) ne sera JAMAIS rentable : le temps d'émission / réception de l'image est largement supérieur au temps de calcul !!
• Inversement, chercher tous les motifs fréquentiels d'un échantillon de signal est presque toujours intéressant à distribuer : la taille de l'échantillon est ridicule par rapport au temps de calcul des diverses transformées de Fourier requises pour l'analyse fréquentielle...

[dhoorens]

Les inputs sont de deux ordres:
*Des tables générales (les 15 Mo) (les données sont dispersées dans disons une vingtaine de tables)
*une table de simulations (contenant une vingtaine de variables (*500 pas de temps) par simulation. Mais toutes les données sont dans une seule table => il s'agit d'une grosse table d'environ ~120 Mb (120Ko par simulation *1000 simulations)

Pour le calcul, je sais pas exactement comment le soft actuel se débrouille. Je ne sais pas s'il fait des copies de ce dont il a besoin sur chacun des pcs ou s'il fait de l'aller retour avec le PC master?

En ce qui concerne les résultats, je ne sais pas ce qu'il fait en interne, mais ce que je sais c'est qu'à la fin du process avec le soft actuel, je recois sur mon pc (PC master) un ensemble de tables dont le total, point de vue mémoire, doit faire de l'ordre de 25Moutputs. Mais écrit il sur chaque PC slave et puis collecte-t-il sur mon pc, ou bien il fait les calculs sur les slaves et rassemble l'écriture sur mon pc?? Je ne sais pas.
Ma solution à moi n'étant pas encore définie, je ne sais pas non plus ce qu'il devrait faire...

A la relecture de ceci, ca fait un beau problème avec beaucoup d'inconnnues :-/

[Mac LAK]

Les inputs sont de deux ordres:
*Des tables générales (les 15 Mo) (les données sont dispersées dans disons une vingtaine de tables)
*une table de simulations (contenant une vingtaine de variables (*500 pas de temps) par simulation. Mais toutes les données sont dans une seule table => il s'agit d'une grosse table d'environ ~120 Mb (120Ko par simulation *1000 simulations)

Déjà, c'est un peu mal barré au vu de la taille des données, je dirais... Cela fait un peu gros à balancer sur le réseau local, tu ne trouves pas ?

Pour le calcul, je sais pas exactement comment le soft actuel se débrouille. Je ne sais pas s'il fait des copies de ce dont il a besoin sur chacun des pcs ou s'il fait de l'aller retour avec le PC master?

Gni ?? Ton soft actuel n'est PAS distribué il me semble, non ?
Donc que sont ces "chacun des PC" et ce "PC master" ??

En ce qui concerne les résultats, je ne sais pas ce qu'il fait en interne, mais ce que je sais c'est qu'à la fin du process avec le soft actuel, je recois sur mon pc (PC master) un ensemble de tables dont le total, point de vue mémoire, doit faire de l'ordre de 25Moutputs.

Tu les reçois comment ? Fichier sur le disque ? Base de données ? Dump sur la sortie standard ? Et pareil pour les données d'entrée, d'ailleurs...

A la relecture de ceci, ca fait un beau problème avec beaucoup d'inconnnues :-/

Oui, beaucoup trop d'ailleurs... Dans ce genre de choses, tu ne peux pas te permettre un "je ne sais pas ce qu'il fait", car tu seras forcément amené à savoir quoi déporter, donc quels sont les traitements exacts et précis qui sont faits, et sur quoi ils sont faits...

[Lavock]

D'après ce que j'ai compris, tu dois donner au client 1*15Mo puis 120 ko par simulation de 15 min ? Pour moi, ça reste raisonnable sur du réseau local au vu du nombre de simulation nécessaire.

[EDIT] Si c'est le cas, les données dont parler Mac Lak sont les 120 ko

[dhoorens]

A problème peu clair, explication plus claire... :-)
Actuellement je dispose d'un PC (2CPU) que j'appelle PC master et de disons 4 PC (8 CPU) que j'appellerai PC Slave.
Sur tous ces PC est installée une application payante fournie par un consultant et gnagnagna.. => bref, peu flexible, payante mais qui fonctionne.
Elle permet de traiter le problème du style for (i = 1-> simuMax) {...}
*OU sur un CPU => ça prendrait 15000 minutes
*OU le faire tourner sur plusieurs CPU et plusieurs machines de la façon suivante:
Sur le PC master je lance le soft, je spécifie quels sont les PC slaves et dès ce moment il calcule et me retourne les résultats => total de l'opération dans ce cas ci: 15000 minutes / (8+2 CPU) = 1500 minutes (la relation est quasi linéaire). Les résultats sont consignés dans des fichiers d'extension .STO (stochastic file format) (à mon avis purement lié au soft en lui-même) que je ne sais lire qu'avec le soft lui même ou avec des DLL spécifiques fournies avec le soft.

En ce qui concerne le calcul, le soft actuel procède de la façon suivante:
il va calculer pour chaque simulation et pour chaque pas de temps un ensemble de choses avec
*pour input des tables de deux ordres (voir réponse plus haut)
*des outputs spécifiés par l'user (mais disons pour faire simple de l'ordre de 25Moutputs au total)

Ces inputs sont tous sur le PC master
Les outputs seront finalement tous consignés sur le PC Master.

Ce qu'il fait entre les opérations Input et Output, je n'en sais rien, puisque le logiciel n'est pas open source. Tout ce que je sais, c'est qu'il le fait et normalement il le fait bien( encore une chance, vu le prix qu'on paye :-) )

Revenons en à mon problème:
J'estime que ce logiciel, outre les problèmes spécifiés intialement, n'est pas suffisement flexible => j'aimerais en refaire un à ma sauce, qui devrait prendre le même genre d'input, qui devrait sortir le même genre d'output, mais les opérations entre "input" et "output" serait différement organisées de manière à ce que ce soit plus flexible...
Cependant, étant donné que je repartirais "from scratch" tout est permis et donc je peux réorganiser les inputs et outputs de la façon la plus adéquate possible=> s'il est nécessaire d'envoyer des ficheirs Input d'abord sur tous les PC slaves et puis de calculer, ou d'avoir un seul fichier input sur le PC master, d'avoir plusieurs fichiers d'outputs sur chaque PC slave, ou un seul gros fichier d'output sur le PC master, ou que sais-je encore ... tout est envisageable.

Donc a priori je ne sais pas ce que couterait un temps d'execution pour une simu, mais mon benchmark (le soft actuel) me dit que ca devrait tourner autour du quart d'heure par simulation.

=> ce que je veux c'est faire tourner ce bidule sur mes 10 CPU (voire plus)

[Cheps]

Pour travailler sur un cluster (tes 5 PC) tu pourrais utiliser MPI, une bibliothèque facile d'utilisation et à mon avis adaptée à ton problème. Tu pourrais aisément créer une application master/slave, ou le master serait chargé de distribué le travail aux slaves (et éventuellement faire une partie du travail lui-même). Tu aurais dans ton cas 1 master et 9 slaves.

[dhoorens]

Pour travailler sur un cluster (tes 5 PC) tu pourrais utiliser MPI, une bibliothèque facile d'utilisation et à mon avis adaptée à ton problème. Tu pourrais aisément créer une application master/slave, ou le master serait chargé de distribué le travail aux slaves (et éventuellement faire une partie du travail lui-même). Tu aurais dans ton cas 1 master et 9 slaves.

Pas de problème(s) si je travaille sous windows? (VS2005 ou VS2008)

[Cheps]

Même si ma seule expérience est sur un cluster Unix, je vois pas de raison que ça te pose problème.

[dhoorens]

et je saurais facilement spécifier la liste de mes PCs slave et que ca tourne "two fingers in the nose"?
Si oui, tu n'aurais pas un petit exemple..?
Cependant, ya pas de raison que les autres bossent pas pdt ce temps.. Vous pouvez toujours proposer d'autres solutions. J'ai l'esprit ouvert :-)
Tks
D

[koala01]

Salut,

Je rebondis un peu sur

Les inputs sont de deux ordres:
*Des tables générales (les 15 Mo) (les données sont dispersées dans disons une vingtaine de tables)
*une table de simulations (contenant une vingtaine de variables (*500 pas de temps) par simulation. Mais toutes les données sont dans une seule table => il s'agit d'une grosse table d'environ ~120 Mb (120Ko par simulation *1000 simulations)
<snip>

Tu as peut être un bon millier de simulation, mais, l'idée est de n'utiliser les données émanant que d'une seule simulation, ou, justement, de travailler avec les données de plusieurs simulation en même temps

Et, s'il s'agit de travailler sur les données émanant de plusieurs simulations, s'agit-il de travailler sur toutes les simulations, ou seulement sur une sélection de certaines d'entre elles

On pourrait aussi se poser la question de savoir si certaines simulations sont actives (comprend: qu'il faille en récupérer les données) pendant qu'un programme analyse les données d'une (ou des ) autres par ailleurs...

Quoi qu'il en soit, il me semblerait opportun d'avoir au minimum une machine ayant une fonction de "serveur" et disposant d'un bon sgbdr pour assurer la persistance

Et je vois assez mal cette machine s'occuper personnellement de l'analyse des données si, à coté de cela, elle est sollicitée quasi en permanence pour stocker de nouvelles données ou d'en sélectionner en vue de les transmettre.

Au final, je dirais que, soit, c'est une machine qui fait tout le boulot, quitte à passer cinq heures à gérer les données, soit il y a une machine qui centralise toutes les données, et "un certain nombre" d'autres machine qui les traitent.

Mais avoir une machine qui centralise les données et qui en traite une partie et qui, en plus doit en transmettre à d'autres machines pour traitement, cela me semble un peu difficile, non