Perl

PERL - Communication processus pere/fils

Recherche :

Mot : Pseudo : Filtrer
Bas de page
Auteur	Sujet : PERL - Communication processus pere/fils

Super_carotte

Bonjour,

La, je bloque vraiment. :??:
Je fait un code qui utilise Parallel:ForkManager afin de pouvoir lancer des processus fils.
Ce que je voudrai, c'est que mes processus fils puissent modifier (en fait supprimer une case) un tableau qui est dans le main().

J'ai vu ces deux sujets:
ici et la

Mais je n'y comprend pas grand chose. Ces bibliothèques sont bien complexe. :whistle:

Exemple de ce que je souhaiterai:

Code :

#!/opt/perl/bin/perl
use strict;
use warnings;
use ForkManager;
my $pm = Parallel::ForkManager->new(10); #nombre de processus max
$pm->run_on_finish( sub {
printf "%s : Process completed: @_\n", scalar localtime
});
my @tableau1=(1,2,3,4,5,6,7,8,9);
while(@tableau1 n'est pas vide) {
foreach(@tableau1){
$pm->start($i) and next;
supprimer l'element en cours de lecture de @tableau1
$pm->finish;
}
}
printf "%s: Waiting for some child to finish\n", scalar localtime;
$pm->wait_all_children;
printf "%s: All processes finished.\n", scalar localtime;

Si quelqu'un arrive a trouver une solution a ce probleme, je lui en serait vraiment reconnaissant. :wahoo:
(Sachant que je ne peux pas utiliser la communication par fichier car ce ne serait pas "suffisamment propre".)
Cordialement,
Benjamin

PS:
Si quelqu’un est curieux de savoir les raison de ces questions:
J’essaie de mettre en place un multi thread sur le code suivant.
Ce code simule un démarrage de Jobs de façon hiérarchisé.
Donc le code suivant fonctionne mais j'aimerai maintenant y appliquer du multi thread lors du démarrage des jobs (actuellement simulé par un "sleep rand 5;" )via la bibliothèque ForkManager.

Code :

#!/usr/bin/perl -w
use strict;
use warnings;
use diagnostics;
use Data::Dumper;
use Parallel::ForkManager;
####################### PACKAGES ###########################
package Job;
my @listJob = ();
my @tabProc = ();
sub new {
my ($class, $ID_PROCESS, $ALIAS, $PERE, $FILS, $LOCK, $TYPE, $STARTED) = @_;
my $this = {};
bless($this, $class);
$this->{ID_PROCESS} = $ID_PROCESS;
$this->{ALIAS} = $ALIAS;
$this->{PERE} = $PERE;
$this->{FILS} = $FILS;
$this->{LOCK} = $LOCK;
$this->{TYPE} = $TYPE;
$this->{STARTED} = $STARTED;
push(@listJob,$ID_PROCESS);
push(@tabProc,$this);
return $this;
}
sub getID {
my ($this) = @_;
return $this->{ID_PROCESS};
}
sub getAlias {
my ($this) = @_;
return $this->{ALIAS};
}
sub getPere {
my ($this) = @_;
return $this->{PERE};
}
sub getFils {
my ($this) = @_;
return $this->{FILS};
}
sub getLock {
my ($this) = @_;
return $this->{LOCK};
}
1;
####################### FIN PACKAGES ###########################
####################### MAIN ###########################
my $pere;
my $fils;
my $LEVEL=0;
$pere = undef;
$fils = "4,5";
my $proc1 = new Job( "1", "alias1", $pere, $fils, "0", "unknown", "0" );
$pere = undef;
$fils = "6";
my $proc2 = new Job( "2", "alias2", $pere, $fils, "0", "unknown", "0" );
$pere = undef;
$fils = "8,9";
my $proc3 = new Job( "3", "alias3", $pere, $fils, "0", "unknown", "0" );
$pere = "1";
$fils = "7";
my $proc4 = new Job( "4", "alias4", $pere, $fils, "0", "unknown", "0" );
$pere = "1";
$fils = "7";
my $proc5 = new Job( "5", "alias5", $pere, $fils, "0", "unknown", "0" );
$pere = "2";
$fils = "8";
my $proc6 = new Job( "6", "alias6", $pere, $fils, "0", "unknown", "0" );
$pere = "4,5";
$fils = "8";
my $proc7 = new Job( "7", "alias7", $pere, $fils, "0", "unknown", "0" );
$pere = "7,5,6,3";
$fils = undef;
my $proc8 = new Job( "8", "alias8", $pere, $fils,, "0", "unknown", "0" );
$pere = "3";
$fils = undef;
my $proc9 = new Job( "9", "alias9", $pere, $fils, "0", "unknown", "0" );
print "listJob : @listJob\n";
print Data::Dumper::Dumper @tabProc;
foreach my $row (@tabProc)
{
if ($row->{PERE} eq undef)
{
$row->{PERE} = "NULL";
}else
{
$row->{PERE} =~ s/,/ /g;
}
if ($row->{FILS} eq undef)
{
$row->{FILS} = "NULL";
}
else
{
$row->{FILS} =~ s/,/ /g;
}
if ($row->{PERE} eq "NULL" )
{
$row->{TYPE} = "PERE-0";
}
else
{
if ($row->{FILS} eq "NULL" )
{
$row->{TYPE} = "FILS";
}
else
{
$row->{TYPE} = "PERE";
}
$row->{STARTED} = 0;
}
$LEVEL+=1;
}
print Data::Dumper::Dumper @tabProc;
print "LEVEL : $LEVEL\n";
my $RETOUR;
my @tabProc_temp=@tabProc;
my @tabProcFini=();
my $i=0;
while( @tabProc_temp )
{
$i=0;
foreach my $row (@tabProc_temp)
{
if ($row->{LOCK} == 0)
{
$RETOUR = "Not OK";
print "PROCESS $row->{ID_PROCESS} lets work on it! \n";
if ($RETOUR eq "OK" )
{
print "PROCESS","$row->{ID_PROCESS} is Running \n";
push(@tabProcFini,$row->{ID_PROCESS});
@tabProc_temp = @tabProc_temp[0..($i-1),($i+1)..$#tabProc_temp];
print "\n";
}
else
{
print "PROCESS ","$row->{ID_PROCESS} is Stopped \n";
if ($row->{TYPE} eq "PERE-0" )
{
sleep rand 5;
print "PROCESS ","$row->{ID_PROCESS} well started \n\n";
push(@tabProcFini,$row->{ID_PROCESS});
@tabProc_temp = @tabProc_temp[0..($i-1),($i+1)..$#tabProc_temp];
}else
{
my @tab1 = split(/ /,$row->{PERE});
my $tailletab1 = scalar @tab1;
my @tab2=@tabProcFini;
my %hash = map{$_ => 1} (@tab1, @tab2);
my @tab = keys %hash;
my $nombre_elements_commun = @tab1 + @tab2 - @tab;
if($nombre_elements_commun == $tailletab1)
{
print "PROCESS ","$row->{ID_PROCESS} Parents: $row->{PERE} \n";
print "PROCESS ","$row->{ID_PROCESS} Les elements de la liste \"PERE\" du process $row->{ID_PROCESS} sont tous présents dans le tableau \@tabProcFini \n";
sleep rand 5;
print "PROCESS ","$row->{ID_PROCESS} well started \n\n";
push(@tabProcFini,$row->{ID_PROCESS});
@tabProc_temp = @tabProc_temp[0..($i-1),($i+1)..$#tabProc_temp];
}else
{
print "PROCESS ","$row->{ID_PROCESS} Les elements de la liste \"PERE\" du process $row->{ID_PROCESS} NE sont PAS tous présents dans le tableau \@tabProcFini \n";
print "PROCESS ","$row->{ID_PROCESS} Let's try another process \n\n";
}
}
$RETOUR = "OK";
if ($RETOUR ne "OK" )
{
print "PROCESS","$row->{ID_PROCESS} not started \n";
exit(1);
}
}
}
else
{
print "$row->{ID_PROCESS} Locked !!! \n";
push(@tabProcFini,$row->{ID_PROCESS});
@tabProc_temp = @tabProc_temp[0..($i-1),($i+1)..$#tabProc_temp];
print "\n";
}
$i++;
#print "tabProc_temp : @tabProc_temp\n";
print "tabProcFini : @tabProcFini\n\n";
}
}

Toutes les propositions sont les bienvenue, je sèche vraiment :ange:

Message édité par Super_carotte le 13-12-2011 à 09:46:33

Publicité

gilou

Modérateur
Modzilla

Vu que dans le modèle standard d'un fork, le processus fils ne partage pas l'environnement mémoire avec son processus père, mais en fait une copie, il n'y a aucune chance que les processus fils accèdent au tableau @tableau1.

Une solution à ce problème est décrite ici: http://docstore.mik.ua/orelly/perl [...] h16_13.htm
Bon, c'est pas portable dans tous les environnements, donc pas portable sous windows par exemple.

Citation :

J’essaie de mettre en place un multi thread sur le code suivant.

Il y a une raison particulière pour réinventer la roue, plutôt qu'utiliser une solution éprouvée comme Coro?

A+,

---------------
There's more than what can be linked! -- Iyashikei Anime Forever! -- AngularJS c'est un framework d'engulé! --

Super_carotte

Bonjour,

Tout d'abord, merci pour cette réponse.

Ce que j'essaie de faire, c'est de mettre en place un script de démarrage de jobs de façon hiérarchisé.
Donc j'ai créé un code (cf ci-dessus) qui fait cela mais sans parallélisation. Maintenant que ce code fonctionne, j’essaie d'y implanter la parallélisation.

Mais étant un débutant en perl, il est fort possible que ma méthode ou que les bibliothèques utilisée ne soient pas les bonnes.

Pensez vous que coro puisse gérer un lancement hiérarchisé d'action en parallèle? En quoi est-il different de ForkManager?
En effet, dans sa description j'ai pu lire:

Citation :

They are similar to kernel threads but don't (in general) run in parallel at the same time even on SMP machines

Du coup, cela ne signifie t'il pas que la parallélisation ne fonctionne pas sur coro?

Merci,
Benjamin

gilou

Modérateur
Modzilla

Comme dit dans une doc, "Coro implements cooperative multitasking/multithreading with explicit task switching, while threads implements scheduled multitasking/multithreading. The advantage of Coro is that you don't get any race conditions. The advantage of threads is that you can get true parallelism across more than one CPU."

Mais si vous avez besoins de threads, pourquoi ne pas avoir utilisé ce qui existait déjà dans perl?
Bon en tout cas, si vous êtes sur une architecture de type unix, votre approche par des fork, plus l'utilisation de mêmoire partagée devrait suffire. Si vous êtes sous Win32, vaut mieux pas penser à cette approche, vu déjà que fork y est émulé par perl. Il doit y avoir moyen de faire ce que vous voulez, mais de manière OS dépendante avec les modules WIN32.

A+,

Message édité par gilou le 13-12-2011 à 16:41:15

---------------
There's more than what can be linked! -- Iyashikei Anime Forever! -- AngularJS c'est un framework d'engulé! --

Super_carotte

Bonjour,
Mon code doit être multi-platefrome car il doit tourner sur des UNIX et des Win32.
Donc pas de fork car ça doit pouvoir tourner sur du win32 et pas d'utilisation de "modules WIN32" car ça doit tourner sur de Unix.

Il me reste quelle option ? :??:

gilou

Modérateur
Modzilla

De partir sur Coro et de laisser tomber le vrai parallélisme (ou de rester avec fork, mais de pas compter dessus sur une plateforme WIN32, ou de toute façon, IPC::Shareable n'a pas l'air d'être supporté), ou éventuellement essayer d'utiliser les threads Perl (mais comme j'ai jamais eu l'occasion de les utiliser dans mes programmes, je en sais s'ils implémentent un vrai parallélisme sous WIN32).
La le problème est pas limité à Perl: a moins de passer par des librairies spécialisées et multiplateformes ajoutant le support du vrai parallélisme la ou il est utile, le problème est assez général à tout code devant fonctionner sur des OS différents.
Il reste aussi la possibilité d'écrire du code OS dépendant avec un test sur l'architecture ($^O) pour décider de ce qui est appelé (un équivalent des ifdef du C) et en ce cas, la lecture de ceci: http://www.perlmonks.org/bare/?node_id=331029 n'est pas inutile pour la partie mémoire partagée et fork sous Windows (le bug est peut être corrigé depuis)
A+,

Message édité par gilou le 14-12-2011 à 13:27:37

---------------
There's more than what can be linked! -- Iyashikei Anime Forever! -- AngularJS c'est un framework d'engulé! --

Super_carotte

Re bonjour, :hello:

Après en avoir parlé avec les collègues, il s’avère que le code ne sera démarré que depuis des Red Hat.
En fait, la Red Hat va se contenter de lancer des ordres de façon parallélisé aux différents serveurs (unix, linux et win32).

Donc il me semble que al solution forkManager reste viable. (tant mieux, coro ne m'a pas semblé evidant a utilisé et je n'ai pas trouvé beaucoup d'exemples sur son utilisation).

Merci de m'avoir donné ton avis,

Cordialement,
Benjamin.

FORUM HardWare.fr

Programmation

Perl

PERL - Communication processus pere/fils

Sujets relatifs
Communication programmes C	[C#] savoir si un processus est en train de réfléchir, possible ?
[C][Gnu] info utilisation memoire, processeur et swap [résolu]	logger ouverture fermeture processus
[Résolu] Gestion d'un Top10 en %hash et de la "casse"	[Résolu] Question sur l'optimisation pour compter le nombre de ligne
communication PHP via socket : permission denied	Communication PHP / C++ via un socket UNIX => blocage read/write
Communication avec port RS232 : Récupération de valeurs chiffrées	perl - lister les fichiers d'un rep
Plus de sujets relatifs à : PERL - Communication processus pere/fils

Page générée en 0.126 secondes