Discussion :

[membreComplexe12]

Bonjour tous,
une fois de plus je sollicite votre aide...

j'ai entendu parler vaguement de "parallélisation" pour diminuer les temps de calcul et je voudrais appliquer cela à un programme que j'ai réalisé j'ai réalisé en C++.
==> le problème: de parallélisation je ne connais que le nom je ne sais pas comment appliquer cela, de plus je suis un "gros débutant en programmation" j'aurais besoin de quelques pistes....

1°) mon programme:
- il récupère les données d'un fichier texte et classe cela dans 400000 vectors où il y a environ 1000 données pour chacun.

- une fois que cela est récupéré on lance une fonction qui fait un certain calcul (qui dure au maximum 1min) pour chaque vector et on enregistre les resultats dans un vector de 400000lignes.

2°) ce que je voudrais faire

je voudrais faire deux choses en parallèle: récupérer les données et lancer les calculs car je pense que le temps de récupération de toutes ces données doit être long (cette partie du programme n'est pas achevée) et je voudrais dès que j'ai un vector lancer le calcul mais tout en continuant en tache de font à récuper les autres vectors.


3°) questions:
- es ce possible de faire avec n'importe quel langage de programmation? et donc avec le c++?
- avez vous des pistes/liens qui explique comment faire ou pouvez vous me donner des pistes ou des exemples sur des cas simples?

Merci d'avance pour votre aide

[fregolo52]

Ce que tu veux faire est un programme multi-thread.
1 thread pour l'acquisition
1 thread pour le calcul

Comme tout programme multi-thread il faut gérer la synchro entre les threads.
Il y a plein d'exemple sur le Net, et il y a sûrement un cours sur ce site.

Tu peux développer en .NET (VB.NET, C#), C/C++, Java ... pour faire ça.

[membreComplexe12]

merci d'avoir pris le temps de répondre

Ce que tu veux faire est un programme multi-thread.
1 thread pour l'acquisition
1 thread pour le calcul

merci déjà je viens d'apprendre deux nouveaux mots

Comme tout programme multi-thread il faut gérer la synchro entre les threads.

oui, cela je ne pense que ca ne doit pas être trop compliqué en utilsant des mot clef du type "pause" et "stop" dans le programme lorsqu'un des thread est fini...
ce qui m'inquiete plus est comment lancer telle tache sur tel processeur ou autre et qu'elles sont les mots clefs et fonction pour faire cela...

Il y a plein d'exemple sur le Net, et il y a sûrement un cours sur ce site.
Tu peux développer en .NET (VB.NET, C#), C/C++, Java ... pour faire ça.

je déjà regardé avec les mots clefs que tu m'as donné et il y a effectivement beaucoup plus de réponses!

[seeme]

En général, il est plus prudent de laisser le scheduleur attribuer les threads aux différents processeurs. Dans 99% des cas, on ne peut que règler l'affinité avec un processeur, le scheduleur va le prendre en compte et essayer de complaire à tes attentes, mais c'est sans garanties.

C'est un peu plus compliqué que pause et start, mais c'est ça (mot clef: yield)

Et pour protéger une ressource, c'est P() et V() (en général, je crois que ça vient d'une convention hongroise un truc du genre..).


edit:

Les noms canoniques P et V venez des initiales de Hollandais mots. V stands pour verhogen, ou « augmentation ». Plusieurs explications ont été données pour P (y compris passeer pour le « passage », probeer « essai », et pakken le « encavateur »), mais en fait le Dijkstra a écrit qu'il a prévu P pour se tenir pour préparé valise mot prolaag,[1] abréviation verlagen de te de probeer, ou « essayer-et-diminuez » [1][2] (A moins ambigu, et une traduction en anglais plus précise et seraient « essaià- diminution ".)

[seeme]

En fait mes 2 premières remarques viennent d'experience sur un forum de débutants. La plupart cherchaient à parralèliser là où en fait un peu de logique permettait de passer par exemple de O(e^n) à O(n).

Mais is tu as de l'experience et que tu sais que ton code est bien comme ça et que les gains en optimisation seront minimes, ne t'angoisse pas et regarde le multi thread

Je ne connais pas fortran mais une recherche rapide sur google montre qu'il existe des lib et des backends avec pthread par exemple. Donc oui, ça doit êtr e possible.

[membreComplexe12]

Mais is tu as de l'experience et que tu sais que ton code est bien comme ça et que les gains en optimisation seront minimes, ne t'angoisse pas et regarde le multi thread

en fait je n'ai pas beaucoup d'expérience en C++ (quasiment =0) mais comme mon programme est très court je ne pense pas que je peux optimiser grand chose.
la seule chose qui prend du temps est la gestion du pas de calcul et cela je vais essayer de l'optimiser au mieux.

Je pense que c'ets le calcul qui va prendre le plus de temps. Et là ça devient clairement plus complexe (dépendant de la nature de ton calcul). Il faut essayer de découper ton calcul en étapes qui ne soient pas dépendantent.

le calcul n'est pas parallelisable car j'ai 3 étapes totalement dépendantes...

Note: fait attention à ne pas tomber dans le piège de l'attente active...

qu'es ce que c'est que cela?

[fregolo52]

Eh oui !! Le plus compliqué dans une recherche c'est d'avoir les bons mots clés !!

[seeme]

Bonjour!

Avant de chercher à parralèliser, il faut se poser la question suivante: "Mon programme nécessite-t-il plusieurs processus?"

A savoir: est-il nécessaire reprendre ton programme (parralèliser est souvent très lourd den terme de refactoring) ou des optimisations pourraient suffire?

Sinon, beaucoup de langages sont parralèlisables (java, C, C++, python...), certains ne le sont pas (VBA).

Pour faire ça, il faut bien comprendre ce qu'est un processus, et un processus léger (thread). Tu peux t'orienter vers boost::thread ou libpthread (plus orienté fonctionnel je crois).

Il faut isoler les traitement. Sur le papier, tu regardes à quel moment tu peux déclencher quel traitement. Il faut être sûr qu'un thread ne va pas tout bloquer (un autre l'attend) et que les variables sont correctement protégées (oui, il y a un espace mémoire commun avec les processus légers, à toi de le gérer).

Les principaux danger avec les threads sont:
* Les goulots: tu pensais améliorer ton programme, mais il met 4 fois plus de temps à cause d'un thread qui fait goulot).

* Ce que j'appelle le faux threading: au final tu as une succession de thread qui dépendent de leur père, tu n'as rien parralèlisé (dans certains cas ça peut être le but recherché, mais assez rarement)

* Les interblocages: là c'est un art.. Il faut protéger les ressources partagées entre les threads. Il faut à tout prix être sûr que quand un thread veut accèder à une ressource (lecteur CD.. Fichier), il est le seul à le faire pour éviter qu'un petit mariole aille modifier les données que tu es en train de lire.

Renseigne toi sur les sémaphores, les files de messages et les moniteur pour voir les différentes problèmatiques et leurs solutions.

Dans ton cas, il y a plusieurs approches..

* Un processus lit les lignes du fichier, et à mesure que les objets sont disponibles, un autre processus effectue le calcul.

* Plusieurs processus lisent des blocs du fichier (par exemple un processus lit 10 lignes et les traite, et tu mets plusieurs processus :p ). A mon avis une de splus intéressante.

* Un processus lit le fichier et plusieurs s'occupent du calcul

* Plusieurs lisent le fichier et un seul fait le calcul

* Plusieurs lisent le fichier et plusieurs font les calculs (à mon avis une des plus mauvaise..)

Et il y en a d'autres...

[membreComplexe12]

salut seeme, merci pour cette reponse très complete

Avant de chercher à parralèliser, il faut se poser la question suivante: "Mon programme nécessite-t-il plusieurs processus?"

je n'ai pas bien compris: tu veux dire que si la lecture prends 30sec et les calculs 30min ca sert à rien de paralléliser, c'est cela ou j'ai mal compris ce que tu voulais dire?

A savoir: est-il nécessaire reprendre ton programme (parralèliser est souvent très lourd den terme de refactoring) ou des optimisations pourraient suffire?

mon programme n'est pas très long et assez modulable donc pas de problème de ce coté là. coté optimisation je ne peux pas faire beaucoup mieux je pense car il est vraiment classique.

Sinon, beaucoup de langages sont parralèlisables (java, C, C++, python...), certains ne le sont pas (VBA).

ok, moi j'utilise C/C++ mais j'aurais peut etre quelque chose à faire en fortran plus tard. est il parallélisable?

Pour faire ça, il faut bien comprendre ce qu'est un processus, et un processus léger (thread). Tu peux t'orienter vers boost::thread ou libpthread (plus orienté fonctionnel je crois).
Il faut isoler les traitement. Sur le papier, tu regardes à quel moment tu peux déclencher quel traitement. Il faut être sûr qu'un thread ne va pas tout bloquer (un autre l'attend) et que les variables sont correctement protégées (oui, il y a un espace mémoire commun avec les processus légers, à toi de le gérer).
Les principaux danger avec les threads sont:
* Les goulots: tu pensais améliorer ton programme, mais il met 4 fois plus de temps à cause d'un thread qui fait goulot).
* Ce que j'appelle le faux threading: au final tu as une succession de thread qui dépendent de leur père, tu n'as rien parralèlisé (dans certains cas ça peut être le but recherché, mais assez rarement)
* Les interblocages: là c'est un art.. Il faut protéger les ressources partagées entre les threads. Il faut à tout prix être sûr que quand un thread veut accèder à une ressource (lecteur CD.. Fichier), il est le seul à le faire pour éviter qu'un petit mariole aille modifier les données que tu es en train de lire.
Rensegne toi sur les sémaphores, les files de messages et les moniteur pour voir les différentes problèmatiques et leurs solutions.
Dans ton cas, il y a plusieurs approches..
* Un processus lit les lignes du fichier, et à mesure que les objets sont disponibles, un autre processus effectue le calcul.
* Plusieurs processus lisent des blocs du fichier (par exemple un processus lit 10 lignes et les traite, et tu mets plusieurs processus :p ). A mon avis une de splus intéressante.
* Un processus lit le fichier et plusieurs s'occupent du calcul
* Plusieurs lisent le fichier et un seul fait le calcul
* Plusieurs lisent le fichier et plusieurs font les calculs (à mon avis une des plus mauvaise..)
Et il y en a d'autres...

je vais regarder tous cela, merci pour ces pistes

En général, il est plus prudent de laisser le scheduleur attribuer les threads aux différents processeurs. Dans 99% des cas, on ne peut que règler l'affinité avec un processeur, le scheduleur va le prendre en compte et essayer de complaire à tes attentes, mais c'est sans garanties.
C'est un peu plus compliqué que pause et start, mais c'est ça (mot clef: yield)
Et pour protéger une ressource, c'est P() et V() (en général, je crois que ça vient d'une convention hongroise un truc du genre..).

d'accord, merci pour ces infos

[fregolo52]

* Ce que j'appelle le faux threading: au final tu as une succession de thread qui dépendent de leur père, tu n'as rien parralèlisé (dans certains cas ça peut être le but recherché, mais assez rarement)

Ca reste quand même le plus simple. Tu fais plusieurs threads dans un même processus. Ca évite les contraintes multi-processus, il y en aura déjà avec avec les synchros et les inter-blocage !!

salut seeme, merci pour cette reponse très complete

Envoyé par seeme
Avant de chercher à parralèliser, il faut se poser la question suivante: "Mon programme nécessite-t-il plusieurs processus?"

je n'ai pas bien compris: tu veux dire que si la lecture prends 30sec et les calculs 30min ca sert à rien de paralléliser, c'est cela ou j'ai mal compris ce que tu voulais dire?

En effet, ca ne sert à rien (à part pour apprendre), sauf si tu peux paralléliser la partie calcul.

[membreComplexe12]

En effet, ca ne sert à rien (à part pour apprendre), sauf si tu peux paralléliser la partie calcul.

- tu as raison rien que pour apprendre qu'es ce que paralléliser je pense que je vais essayer.

- par contre pour l'utilité je ne sais pas trop car je n'ai pas la notion du temps de calcul pour lire toutes ces données (et comme je ne les ai pas encore je ne peux pas faire le test)

[seeme]

Je pense que c'ets le calcul qui va prendre le plus de temps. Et là ça devient clairement plus complexe (dépendant de la nature de ton calcul). Il faut essayer de découper ton calcul en étapes qui ne soient pas dépendantent.

Donc si tu as disons 3 étapes A, B, C avec A et B indépendant, et C qui dépend de A et de B, tu peux essayer de parralèliser le calcul de A et de B avec C qui attent les résultats des 2 autres.

Note: fait attention à ne pas tomber dans le piège de l'attente active...