PERL - Communication processus pere/fils

PERL - Communication processus pere/fils - Perl - Programmation

Marsh Posté le 13-12-2011 à 09:43:40    

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 :
  1. #!/opt/perl/bin/perl
  2. use strict;
  3. use warnings;
  4. use ForkManager;
  6. my $pm = Parallel::ForkManager->new(10);        #nombre de processus max
  7. $pm->run_on_finish( sub {
  8.     printf "%s : Process completed: @_\n", scalar localtime
  9. });
  11. my @tableau1=(1,2,3,4,5,6,7,8,9);
  13. while(@tableau1 n'est pas vide) {
  14. foreach(@tableau1){
  15.     $pm->start($i) and next;
  16.     supprimer l'element en cours de lecture de @tableau1
  17.     $pm->finish;
  18. }
  19. }
  21. printf "%s: Waiting for some child to finish\n", scalar localtime;
  22. $pm->wait_all_children;
  24. 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 :
  1. #!/usr/bin/perl -w
  2. use strict;
  3. use warnings;
  4. use diagnostics;
  6. use Data::Dumper;
  7. use Parallel::ForkManager;
  9. ####################### PACKAGES ###########################
  10. package Job;
  11. my @listJob = ();
  12. my @tabProc = ();
  13. sub new {
  15.    my ($class, $ID_PROCESS, $ALIAS, $PERE, $FILS, $LOCK, $TYPE, $STARTED) = @_;
  16.    my $this = {};
  17.    bless($this, $class);
  18.  
  20.    $this->{ID_PROCESS} = $ID_PROCESS;
  21.    $this->{ALIAS} = $ALIAS;
  22.    $this->{PERE} = $PERE;
  23.    $this->{FILS} = $FILS;
  24.    $this->{LOCK} = $LOCK;
  25.    $this->{TYPE} = $TYPE;
  26.    $this->{STARTED} = $STARTED;
  27.  
  28.  
  29.   push(@listJob,$ID_PROCESS); 
  30.   push(@tabProc,$this);
  32. return $this;
  33.    }
  34.  
  35.  
  36. sub getID {
  37. my ($this) = @_;
  38. return $this->{ID_PROCESS};
  39. }
  40. sub getAlias {
  41. my ($this) = @_;
  42. return $this->{ALIAS};
  43. }
  44. sub getPere {
  45. my ($this) = @_;
  46. return $this->{PERE};
  47. }
  48. sub getFils {
  49. my ($this) = @_;
  50. return $this->{FILS};
  51. }
  52. sub getLock {
  53. my ($this) = @_;
  54. return $this->{LOCK};
  55. }
  56. 1;
  57. ####################### FIN PACKAGES ###########################
  61. ####################### MAIN ###########################
  62. my $pere;
  63. my $fils;
  64. my $LEVEL=0;
  66. $pere = undef;
  67. $fils = "4,5";
  68. my $proc1 = new Job( "1", "alias1", $pere, $fils, "0", "unknown", "0" );
  70. $pere = undef;
  71. $fils = "6";
  72. my $proc2 = new Job( "2", "alias2", $pere, $fils, "0", "unknown", "0" );
  74. $pere = undef;
  75. $fils = "8,9";
  76. my $proc3 = new Job( "3", "alias3", $pere, $fils, "0", "unknown", "0" );
  78. $pere = "1";
  79. $fils = "7";
  80. my $proc4 = new Job( "4", "alias4", $pere, $fils, "0", "unknown", "0" );
  82. $pere = "1";
  83. $fils = "7";
  84. my $proc5 = new Job( "5", "alias5", $pere, $fils, "0", "unknown", "0" );
  86. $pere = "2";
  87. $fils = "8";
  88. my $proc6 = new Job( "6", "alias6", $pere, $fils, "0", "unknown", "0" );
  90. $pere = "4,5";
  91. $fils = "8";
  92. my $proc7 = new Job( "7", "alias7", $pere, $fils, "0", "unknown", "0" );
  94. $pere = "7,5,6,3";
  95. $fils = undef;
  96. my $proc8 = new Job( "8", "alias8", $pere, $fils,, "0", "unknown", "0" );
  98. $pere = "3";
  99. $fils = undef;
  100. my $proc9 = new Job( "9", "alias9", $pere, $fils, "0", "unknown", "0" );
  103. print "listJob : @listJob\n";
  104. print Data::Dumper::Dumper @tabProc;
  108.  foreach my $row (@tabProc)
  109. {
  110.  if ($row->{PERE} eq undef)
  111.  {
  112.   $row->{PERE} = "NULL";
  113.  }else
  114.  {
  115.   $row->{PERE} =~ s/,/ /g;
  116.  }
  118.  if ($row->{FILS} eq undef)
  119.  {
  120.   $row->{FILS} = "NULL";
  121.  }
  122.  else
  123.  {
  124.   $row->{FILS} =~ s/,/ /g;
  125.  }
  127.  if ($row->{PERE} eq "NULL" )
  128.  {
  129.   $row->{TYPE} = "PERE-0";
  130.  }
  131.  else
  132.  {
  133.   if ($row->{FILS} eq "NULL" )
  134.   {
  135.    $row->{TYPE} = "FILS";
  136.   }
  137.   else
  138.   {
  139.    $row->{TYPE} = "PERE";
  140.   }
  142.   $row->{STARTED} = 0;
  143.  }
  144.  $LEVEL+=1;
  145. }
  147. print Data::Dumper::Dumper @tabProc;
  148. print "LEVEL : $LEVEL\n";
  152. my $RETOUR;
  153. my @tabProc_temp=@tabProc;
  154. my @tabProcFini=();
  155. my $i=0;
  157. while( @tabProc_temp )
  158. {
  159. $i=0;
  160.  foreach my $row (@tabProc_temp)
  161.  {
  162.   if ($row->{LOCK} == 0)
  163.   {
  164.    $RETOUR = "Not OK";
  165.    print "PROCESS $row->{ID_PROCESS} lets work on it! \n";
  166.    if ($RETOUR eq "OK" )
  167.    {
  168.     print "PROCESS","$row->{ID_PROCESS} is Running \n";
  169.     push(@tabProcFini,$row->{ID_PROCESS});
  170.     @tabProc_temp = @tabProc_temp[0..($i-1),($i+1)..$#tabProc_temp];
  171.     print "\n";
  172.    }
  173.    else
  174.    {
  175.     print "PROCESS ","$row->{ID_PROCESS} is Stopped \n";
  177.     if ($row->{TYPE} eq "PERE-0" )
  178.     {
  179.      sleep rand 5;
  180.      print "PROCESS ","$row->{ID_PROCESS} well started \n\n";
  181.      push(@tabProcFini,$row->{ID_PROCESS});
  182.      @tabProc_temp = @tabProc_temp[0..($i-1),($i+1)..$#tabProc_temp];
  183.     }else
  184.     {
  186.      my @tab1 = split(/ /,$row->{PERE});
  187.      my $tailletab1 = scalar @tab1;
  188.      my @tab2=@tabProcFini;
  189.      my %hash = map{$_ => 1} (@tab1, @tab2);
  190.      my @tab = keys %hash;
  191.      my $nombre_elements_commun = @tab1 + @tab2 - @tab;
  193.      if($nombre_elements_commun == $tailletab1)
  194.      {
  195.       print "PROCESS ","$row->{ID_PROCESS} Parents: $row->{PERE} \n";
  196.       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";
  197.       sleep rand 5;
  198.       print "PROCESS ","$row->{ID_PROCESS} well started \n\n";
  199.       push(@tabProcFini,$row->{ID_PROCESS});
  200.       @tabProc_temp = @tabProc_temp[0..($i-1),($i+1)..$#tabProc_temp];
  201.      }else
  202.      {
  203.       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";
  204.       print "PROCESS ","$row->{ID_PROCESS} Let's try another process \n\n";
  205.      }
  206.     }
  207.     $RETOUR = "OK";
  208.     if ($RETOUR ne "OK" )
  209.     {
  210.      print "PROCESS","$row->{ID_PROCESS} not started \n";
  211.      exit(1);
  212.     }
  213.    }
  214.   }
  215.   else
  216.   {
  217.    print "$row->{ID_PROCESS} Locked !!! \n";
  218.    push(@tabProcFini,$row->{ID_PROCESS});
  219.    @tabProc_temp = @tabProc_temp[0..($i-1),($i+1)..$#tabProc_temp];
  220.    print "\n";
  221.   }
  222.  $i++;
  223.  #print "tabProc_temp : @tabProc_temp\n";
  224.  print "tabProcFini : @tabProcFini\n\n";
  225.  }
  226. }


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


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

Marsh Posté le 13-12-2011 à 09:43:40   

Reply

Marsh Posté le 13-12-2011 à 13:24:43    

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é!  --
Reply

Marsh Posté le 13-12-2011 à 15:51:51    

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

Reply

Marsh Posté le 13-12-2011 à 16:17:35    

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é!  --
Reply

Marsh Posté le 14-12-2011 à 10:01:40    

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 ?  :??:

Reply

Marsh Posté le 14-12-2011 à 11:49:24    

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é!  --
Reply

Marsh Posté le 16-12-2011 à 09:15:49    

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.

Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed