Discussion :

[RainManOfQc]

Bonjours! premier post ici alors on va essayer de pas le ruiner!
je vais essayer de décrire la situation le plus clairement possible.. ce qui n'est peut-être pas facile avec mon inexpérience en Fortran..

*************
Situation:

Je veux separer les iteration sur Nprocs (idéalement de facon block-cyclique)

la matrice de départ est de dimension (nb,6) ou nb va avec le nomrbe de particules dans le systeme (présentement tres peu mais aussitot que ca va etre fonctionel on va pouvoir pousser un peu).. donc on a un "tall matrice"

je voudrais diviser la matrice en X sub matrice (row-major) pour distribuer ca sur les procs .. ca ne seras pas trop evident pour moi mais ce n'est pas le plus gros du problème...

***************
Problème:

Tout les processus sont "nested" dans une main loop . (qui doit etre syncro) .. c.a.d que a chaque debut de loop la matrice globale est updater avec les resultat de tout les iterations pour ainsi pouvoir commencer le cycle suivant..

j'ai pense a allgather .. mais le probleme c'est que ca ne semble pas fonctionner pour des matrices. Dans tout ce que j'ai lus dernierement personne semblent parler de comment récupérer le résultat des diffèrents procs et les mettrent dans la même matrice..

une autre solution que j'ai pensé est de dumper les résultats de chaque procs sur le NFS (qui est en commun) et a chaque debut de loop de mettre les fichier en séquence dans la matrice de base.. mais cette solution m'enchante pas beaucoup.... vraiment pas beaucoup a vrais dire .. sauf si c'est la seule solution.......

**********
Précision:

je dois avoir la matrice complete dans la memoire de chaque procs car ce programe sert a solutionner un probleme a N-corps en résolvant X problème à 2-corps .. et la "nouvelle matrice" n'est pas necesaire avant le debut de la loop suivante .. donc le gather des resultats doit se faire a la fin de la loop, pour synchronise le tout.


La solution est peut-etre évidente mais je dois avouer que présentement je tourne en rond avec ca... mon code run #1 sur 1 machine. C'est suffisant car j'ai 31 particules dans le systeme pour faire les test ... une fois que les test vont être terminés je vais tomber a 200-300.. 1000-2000(si le programme et le cluster peuvent le supporter compte tenu du délais que l'ont a)

Donc si vous avez une solution ou un document référence que je pourrais lire pour m'éclairer sur le sujet ! ... ca m'aiderais beaucoup
c'est pour une recherche(ecole)

Merci

[genteur slayer]

tu poses des problème de parallelisation un peu classique... en général, pour ne pas avoir à se poser des questions de ce type, on utilise des librairy oùu tout est presque fait. je te conseille de regarder les possibilités de MPI notament dans la bibliotèque mpich2

[RainManOfQc]

Je vois ! si c'etais mon domaine je trouverais put-etre ca simple mais ce n'est pas le cas ...

apres quelque lecture suite a ta reponse .. je presume que le RMA serais une bonne facon d'updater la matrice globale a la fin d'un cycle...

mais ca reste que au debut du cycle le proc 0 doit envoyer la nouvelle matrice a tout les autre procs ...

et la je sais pas trop comment m'y prendre pour envoyer une matrice complete a tout les procs.... il doit surement avoir une facon ou un peu du style du RMA put mais qui est effectif sur tout les procs ...

ca semble simple a faire.. mais je ne reussi toujours pas a mettre la main sur les librairie deja toutes faites!

je dois vraiment pas chercher a la bonne place .. parce que ta reponse sous-entendais quelque chose d'évident ...

[genteur slayer]

on, ça n'a rien d'évident, bien au contraire, je ne sais pas comment cela fonctionne exactement, moi j'utilise la birairie mpich2, qui utilise la norme MPI pour la parallélisation. MPI regroupe bon nombre de fonction et subroutines.

pour parallèliser il y a plusioeures solutions (comme toujours) dans ton cas, tu as un processus maitre (apparament le proc 0) qui distribue la charge de calcul et c'est un procédé que je ne connais pas: moi j'ai prosieurs processus sans relation maitre-esclaves et donc un processus, lorsqu'il a besoin de données "externe" va les demander au processus qui les détiend et ainsi de suite, en fin de boucle un processus va essayer de réunir certaine données nécéssitant le calcul de tous les processus (par exemple un calcul de pas de temps qui sera commun à tout le monde)
Or ces fonctions de rassemblement, et de diffusion ensuite, sont déjà impléménté dans la bibli MPI

Point clé dans la parallèlisation auquel il faut porté une grande attention: IL FAUT que les communiquations entre processus (que ce soit maitre-esclave ou autre) doivent se réduire au minimum possible il est parfois préférable que tous les process calculent la même chose au même moment plustôt qu'un seul calcul et le communique aux autres processus. je m'explique: dans la parallèlisation la partie la plus lente c'est la communication, il arrive fréquemment que le temps gagné en calcul soit perdu en temps de communication entre les process.
Passer l'intégralité d'une matrice à un process est en général une mauvaise idée.
exemple: mettons que tu cherche le max d'un tableau qui a été découpé entre plusieurs processus. plusieur solution:
1) tous les process esclave envoie leur matrice au maitre qui la réassemble et en cherche le max.
2) chaque process cherche le max de sont tableau local et envoie ce résultat au process maitre qui cherche le max de tous ces "max locaux"
----->dans le 1) une grande quantité d'info va transité sur le réseau (très lent) et pendant ce temps les process se tournent les pouces. Dans le 2) très peu de communiquation (seul un élément par process) on a un algo bien plus éficasse!!!

Pour ton problème il est important de savoir:
- qu'est-ce qu'un processus a rééllement besoin de sovoir sur ses voisins (il n'est pas forcément nécéssaire de connaitre tout sur tout le monde)
- qu'est qui peut être calculé par étape (à la manière du max)
- si je prend un process au hasard tout seul de quoi as-t-il beson pour me cracher le résultat local
Tou cela afin de limiter au maximum les transit réseau