Discussion :

[[Hugo]]

Bonjour,

Je suis en train d'essayer d'écrire un petit script qui distribuerait l'exécution de calculs sur plusieurs threads via perl. L'idée est que chaque thread appelle le code de calcul (fortran). Les fichiers à traiter sont répartis dans des répertoires et ilfaut que les threads se baladent de répertoire en répertoire, exécute le calcule, puis passe au suivant, jusqu'à épuisement des répertoires. Je suis très très débutant avec les threads. À ce que j'ai compris, c'est un cas de gestion par "pool". Le nombre de threads est fixé à 7 et il y a environ 30 répertoires à traiter une dizaine de fois - environ 300 en tout. Un calcul fortran dure dans les 2500 secondes - d'où le désir de paralléliser tout ça (outre que c'est fun d'apprendre). Pour le moment, j'en suis à l'état ci-dessous, qui est très préliminaire et ne contient pas encore l'appelle system ('calcul_fortran') qui va bien. Mon problème est que les threads ne se promènent qu'une fois dans une première série de répertoire, et ne passent pas par chacun d'entre eux...

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
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#!/usr/bin/perl -w
use strict;
use warnings;
use Thread::Pool;
my %resolved : shared;
 
use Cwd;
 
my @replist;#liste des répertoires à traiter
 
sub do {#fonction bidon pour vérifier que le thread est passé dans le répertoire : devra appeler le code fortran à terme
    chdir $_[0];
    system ('touch thread_'. Thread::Pool->jobid .'_was_here');
    chdir '..';
}
my $rep;
foreach  $rep ( <*> )#création de la liste des répertoires à traiter
{
 next if( ! -d $rep );#si c'est un répertoire
 next if( ! -f $rep.'/TITI6');#il faut un fichier de positions
 push(@replist, $rep) if(! -f $rep.'/INTERFERENCE.csv');#si pas de fichier INTERFERENCE déjà présent
}
 
if (1 < @replist){#il y a des répertoires à traiter : il faut les distribuer entre les threads puis exécuter
     #Il faut répartir sur au plus 8 threads
     my $pool = Thread::Pool->new(
       {
         workers => 8,
         do => \&do,
         monitor => \&monitor,
       }
     );
 
     while (@replist){
         $pool->add( pop @replist ) ;
     }
    $pool->join();
 
}
else{
    if(1 == @replist){#il n'y a qu'un fichier à traiter
    }
}

Toute suggestion serait la bienvenue !

Merci beaucoup,

Marc

[Gardyen]

je ne sais pas si tu as vu, tu as des exemples ici

[[Hugo]]

Bonjour Gardyen,

Oui, j'avais vu, merci beaucoup pour ta réponse ! Mais j'avoue ne pas bien comprendre ce qu'il s'y passe - je ne suis pas très fluent en perl et beaucoup de notations me sont encore très mystérieuses dans ces exemples...

Marc

[Lolo78]

Hum, ce que je vais dire est un avis purement personnel et la façon dont je vais l'exprimer pourra sembler quelque peu extrémiste aux yeux de certains.

D'abord un fait objectif: depuis Perl 5.20 (sorti en mai 2014), l'utilisation des threads Perl est officiellement "non recommandée". Le terme anglais est "discouraged", si je me souviens bien, ce qui est différent de "deprecated" (la différence est qu'une fonctionnalité "deprecated" sera vraisemblablement retirée dans une prochaine version, alors qu'une fonctionnalité "discouraged" devrait continuer à être supportée pour un moment, même si elle n'est pas recommandée). Et je précise aussi que cet usage n'a jamais été vraiment recommandé; c'est pour cela que les distributions de Perl sont généralement compilées sans le support aux threads, au moins sous Linux et Unix (je crois que la distribution Activestate sous Windows inclut les threads, mais cela a surtout à voir avec le fait que les processus Windows sont beaucoup plus lourds que les processus Unix: du coup, l'utilisation de processus légers (ou threads) a un réel intérêt sous Windows, beaucoup moins sous Linux).

Perso, au moins sous Linux ou Unix, je recommanderais plutôt a priori l'utilisation de fork pour créer des processus, et/ou de modules gérant les processus, comme Parallel::ForkManager, MPI, PVM ou de frameworks (il paraît que le terme officiel français est "cadriciel", on nage en plein délire) de type gestion d'événements comme POE, même si je dois clairement reconnaître que je ne les connais que très partiellement (bref, je ne suis vraiment pas spécialiste, mon avis vaut ce qu'il vaut).

C'était aujourd'hui le premier jour des Journées Perl 2014. Le sujet a justement été abordé. En résumé de la discussion assez animée sur le sujet, je crois pouvoir dire ce qui suit:
- Les threads ont été introduits en Perl essentiellement pour Windows, en raison de la lourdeur des processus Windows;
- Sous Unix ou Linux, la différence entre un thread et un process est presque anecdotique en terme de consommation de ressources (la différence concerne plutôt les variables partagées ou non entre les processus);
- Sous Windows, il y a une réelle différence, et, donc, il y a de nombreux programmes Windows qui utilisent à raison les threads malgré des difficultés de programmation bien réels;
- Le modèle de threads de Perl est utilisable pour des problèmes réels, mais n'a jamais été vraiment au point et pose toutes sortes de problèmes compliqués;
- De très nombreux modules du CPAN ne sont pas "thread-safe".

En bref, je ne recommande pas d'utiliser les threads, sauf cas particulier sous Windows. Mais je répète que ce n'est qu'un avis personnel.

Mais comme il me semble que tu travailles sans doute sous Linux ou Unix, il est peu probable que les threads Perl soient ce dont tu as besoin.

[[Hugo]]

Bonjour Lolo78,

Un très grand merci pour ta réponse !! Bon, ben, il me reste à apprendre ce que c'est que fork et comment ça marche - je suis effectivement sous linux ;-).

Bonne journée !

Marc

[djibril]

Bonjour,

Utilise le module Parallel::ForkManager.

Je l'utilise sous Linux et même sous Windows et il fonctionne très bien.

[Jedai]

'idée est que chaque thread appelle le code de calcul (fortran). Les fichiers à traiter sont répartis dans des répertoires et ilfaut que les threads se baladent de répertoire en répertoire, exécute le calcule, puis passe au suivant, jusqu'à épuisement des répertoires. Je suis très très débutant avec les threads. À ce que j'ai compris, c'est un cas de gestion par "pool". Le nombre de threads est fixé à 7 et il y a environ 30 répertoires à traiter une dizaine de fois - environ 300 en tout. Un calcul fortran dure dans les 2500 secondes - d'où le désir de paralléliser tout ça (outre que c'est fun d'apprendre).

Juste pour appuyer ce qu'ont dit les autres, ton problème ne profiterait en rien des threads, la granularité est bien trop important pour que l'utilisation de threads fasse la moindre différence (quelque soit le langage), des processus sont ici parfaitement appropriés. Par contre, inutile de créer trop de processus, selon le nombre de coeurs de ton processeur (et sa capacité d'hyperthreading), il faudra ajuster le nombre de processus dans le pool.

--
Jedaï

[[Hugo]]

Hello Jedai,

Oui, merci pour l'idée - je ne pensais pas en mettre plus que le nombre de cœurs. J'ai cru comprendre que ça pouvait mal se passer au-delà...

[[Hugo]]

Parallel::ForkManager marche nickel !!! Merci infiniment à tous :-)

[Philou67430]

J'arrive peut-être un peu tard, mais si le besoin est d'exécuter en parallèle des "commandes" dans différents répertoires sous Linux (appel d'un programme Fortran), l'usage de Make est peut-être à envisager (make -j 7 : exécute make en parallélisant jusqu'à 7 processus).