Je suis en train de d=E9velopper une application qui compare les
fichiers sur les comptes de 2 serveurs diff=E9rents. Je passe par un
module m=E9tier pour faire les connexions :
# ... initialisation des variables ...
# acces aux machines concernees
my $cnx1 =3D ...;
my $cnx2 =3D ...;
# on cartographie les repertoires a partir de la racine
my @fichiers1 =3D $cnx1->executer('find . |grep -v "\.log$"');
my @fichiers2 =3D $cnx2->executer('find . |grep -v "\.log$"');
# on fait le diff
my $diff =3D List::Compare->new(\@fichiers1, \@fichiers2);
# ... traitements ...
L'inconvenient de cette m=E9thode est que le script attend que le
traitement soit fini sur cnx1 pour attaquer celui sur cnx2. N'ayant
jamais fait de traitement parall=E8les en perl, je ne sais pas trop dans
quelle voie chercher pour am=E9liorer la chose : un fork ne me semble
pas adapt=E9, les modules de threads ne sont pas tous impl=E9ment=E9s pour
mon architecture (sun4-solaris-64int). Sans forc=E9ment me donner des
bouts de code, dans quelle voie chercheriez-vous ?
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Sébastien Cottalorda
wrote:
Bonjour,
Je suis en train de développer une application qui compare les fichiers sur les comptes de 2 serveurs différents. Je passe par un module métier pour faire les connexions :
# ... initialisation des variables ...
# acces aux machines concernees my $cnx1 = ...; my $cnx2 = ...;
# on cartographie les repertoires a partir de la racine my @fichiers1 = $cnx1->executer('find . |grep -v ".log$"'); my @fichiers2 = $cnx2->executer('find . |grep -v ".log$"');
# on fait le diff my $diff = List::Compare->new(@fichiers1, @fichiers2);
# ... traitements ...
L'inconvenient de cette méthode est que le script attend que le traitement soit fini sur cnx1 pour attaquer celui sur cnx2. N'ayant jamais fait de traitement parallèles en perl, je ne sais pas trop dans quelle voie chercher pour améliorer la chose : un fork ne me semble pas adapté, les modules de threads ne sont pas tous implémentés pour mon architecture (sun4-solaris-64int). Sans forcément me donner des bouts de code, dans quelle voie chercheriez-vous ?
Merci,
Bonjour,
En ce qui me concerne, j'utiliserai un fork ou un thread. Cela permettrai au "père" d'effectuer une tâche pendant que le fils fait l'autre. Le soucis c'est le "partage" de l'information que chacun a recolté de son côté. Pour cela vous avez le choix :
1-/Variable, tableau, hachage partagé (j'ai une préférence pour le hachage) exemple: En utilisant le module Tie::Shareable, vous pouvez partager le hachage : %partage =( 'cnx1' => qw /fichier1 fichier2/, 'cnx2' => qw /fichier2 fichier3 fichierN/, ); Le père remplie le tableau @{$partage{cnx1}}, tandis que le fils, lui, remplie @{$partage{cnx2}}. Vous pouvez alors comparer @{$partage{cnx1}} avec @{$partage{cnx2}} ATTENTION1, il vous faut d'abord mettre en place un mécanisme qui vous garantisse que les 2 processus/threads (père et fils) aient fini leur travail respectif : par exemple l'envoie d'un signal au père par le fils. ATTENTION2, il faudra gérer un timeout : Si le fils n'envoi jamais le signal --> vous pouvez attendre longtemps.
2-/Un pipe (ou tube nommé) : Le père et le fils ouvrent un tube et le fils renvoie le résultat via ce pipe. ATTENTION, il faudra gérer un timeout : Si le fils n'envoie jamais rien --> vous pouvez attendre longtemps.
3-/Une application via socket: Il vous faudra alors une machine récoltant le résultat final, un miniserveur sur chaque machine sur laquelle effectuer votre commande grep. Le MASTER envoie les ordres, puis attends patiemment le résultat qu'il est censé recevoir via une socket. ATTENTION, il faudra gérer un timeout : Si un des miniserveur n'envoi jamais son résultat --> vous pouvez attendre longtemps.
Je ne connais pas trop votre architecture, mais si les pipes sont implémentés, la deuxième méthode est peut être la bonne pour vous.
J'espère que cela vous aidera.
Sébastien
pu1tlcqwx0gydmq@jetable.com wrote:
Bonjour,
Je suis en train de développer une application qui compare les
fichiers sur les comptes de 2 serveurs différents. Je passe par un
module métier pour faire les connexions :
# ... initialisation des variables ...
# acces aux machines concernees
my $cnx1 = ...;
my $cnx2 = ...;
# on cartographie les repertoires a partir de la racine
my @fichiers1 = $cnx1->executer('find . |grep -v ".log$"');
my @fichiers2 = $cnx2->executer('find . |grep -v ".log$"');
# on fait le diff
my $diff = List::Compare->new(@fichiers1, @fichiers2);
# ... traitements ...
L'inconvenient de cette méthode est que le script attend que le
traitement soit fini sur cnx1 pour attaquer celui sur cnx2. N'ayant
jamais fait de traitement parallèles en perl, je ne sais pas trop dans
quelle voie chercher pour améliorer la chose : un fork ne me semble
pas adapté, les modules de threads ne sont pas tous implémentés pour
mon architecture (sun4-solaris-64int). Sans forcément me donner des
bouts de code, dans quelle voie chercheriez-vous ?
Merci,
Bonjour,
En ce qui me concerne, j'utiliserai un fork ou un thread.
Cela permettrai au "père" d'effectuer une tâche pendant que le fils fait
l'autre.
Le soucis c'est le "partage" de l'information que chacun a recolté de
son côté.
Pour cela vous avez le choix :
1-/Variable, tableau, hachage partagé (j'ai une préférence pour le hachage)
exemple: En utilisant le module Tie::Shareable, vous pouvez partager le
hachage :
%partage =(
'cnx1' => qw /fichier1 fichier2/,
'cnx2' => qw /fichier2 fichier3 fichierN/,
);
Le père remplie le tableau @{$partage{cnx1}}, tandis que le fils, lui,
remplie @{$partage{cnx2}}.
Vous pouvez alors comparer @{$partage{cnx1}} avec @{$partage{cnx2}}
ATTENTION1, il vous faut d'abord mettre en place un mécanisme qui vous
garantisse que les 2 processus/threads (père et fils) aient fini leur
travail respectif : par exemple l'envoie d'un signal au père par le fils.
ATTENTION2, il faudra gérer un timeout : Si le fils n'envoi jamais le
signal --> vous pouvez attendre longtemps.
2-/Un pipe (ou tube nommé) : Le père et le fils ouvrent un tube et le
fils renvoie le résultat via ce pipe.
ATTENTION, il faudra gérer un timeout : Si le fils n'envoie jamais rien
--> vous pouvez attendre longtemps.
3-/Une application via socket:
Il vous faudra alors une machine récoltant le résultat final, un
miniserveur sur chaque machine sur laquelle effectuer votre commande grep.
Le MASTER envoie les ordres, puis attends patiemment le résultat qu'il
est censé recevoir via une socket.
ATTENTION, il faudra gérer un timeout : Si un des miniserveur n'envoi
jamais son résultat --> vous pouvez attendre longtemps.
Je ne connais pas trop votre architecture, mais si les pipes sont
implémentés, la deuxième méthode est peut être la bonne pour vous.
Je suis en train de développer une application qui compare les fichiers sur les comptes de 2 serveurs différents. Je passe par un module métier pour faire les connexions :
# ... initialisation des variables ...
# acces aux machines concernees my $cnx1 = ...; my $cnx2 = ...;
# on cartographie les repertoires a partir de la racine my @fichiers1 = $cnx1->executer('find . |grep -v ".log$"'); my @fichiers2 = $cnx2->executer('find . |grep -v ".log$"');
# on fait le diff my $diff = List::Compare->new(@fichiers1, @fichiers2);
# ... traitements ...
L'inconvenient de cette méthode est que le script attend que le traitement soit fini sur cnx1 pour attaquer celui sur cnx2. N'ayant jamais fait de traitement parallèles en perl, je ne sais pas trop dans quelle voie chercher pour améliorer la chose : un fork ne me semble pas adapté, les modules de threads ne sont pas tous implémentés pour mon architecture (sun4-solaris-64int). Sans forcément me donner des bouts de code, dans quelle voie chercheriez-vous ?
Merci,
Bonjour,
En ce qui me concerne, j'utiliserai un fork ou un thread. Cela permettrai au "père" d'effectuer une tâche pendant que le fils fait l'autre. Le soucis c'est le "partage" de l'information que chacun a recolté de son côté. Pour cela vous avez le choix :
1-/Variable, tableau, hachage partagé (j'ai une préférence pour le hachage) exemple: En utilisant le module Tie::Shareable, vous pouvez partager le hachage : %partage =( 'cnx1' => qw /fichier1 fichier2/, 'cnx2' => qw /fichier2 fichier3 fichierN/, ); Le père remplie le tableau @{$partage{cnx1}}, tandis que le fils, lui, remplie @{$partage{cnx2}}. Vous pouvez alors comparer @{$partage{cnx1}} avec @{$partage{cnx2}} ATTENTION1, il vous faut d'abord mettre en place un mécanisme qui vous garantisse que les 2 processus/threads (père et fils) aient fini leur travail respectif : par exemple l'envoie d'un signal au père par le fils. ATTENTION2, il faudra gérer un timeout : Si le fils n'envoi jamais le signal --> vous pouvez attendre longtemps.
2-/Un pipe (ou tube nommé) : Le père et le fils ouvrent un tube et le fils renvoie le résultat via ce pipe. ATTENTION, il faudra gérer un timeout : Si le fils n'envoie jamais rien --> vous pouvez attendre longtemps.
3-/Une application via socket: Il vous faudra alors une machine récoltant le résultat final, un miniserveur sur chaque machine sur laquelle effectuer votre commande grep. Le MASTER envoie les ordres, puis attends patiemment le résultat qu'il est censé recevoir via une socket. ATTENTION, il faudra gérer un timeout : Si un des miniserveur n'envoi jamais son résultat --> vous pouvez attendre longtemps.
Je ne connais pas trop votre architecture, mais si les pipes sont implémentés, la deuxième méthode est peut être la bonne pour vous.
J'espère que cela vous aidera.
Sébastien
Denis
Bonjour,
Merci pour cette réponse. J'ai bien vérifié et les threads ne sont pas implémentés, donc j'attaque la lecture de perlfork (je vais plutôt m'orienter vers un tableau partagé pour ne pas avoir à trop changer le code qui suit).
Merci,
-- Denis
Bonjour,
Merci pour cette réponse. J'ai bien vérifié et les threads ne sont
pas implémentés, donc j'attaque la lecture de perlfork (je vais
plutôt m'orienter vers un tableau partagé pour ne pas avoir à trop
changer le code qui suit).
Merci pour cette réponse. J'ai bien vérifié et les threads ne sont pas implémentés, donc j'attaque la lecture de perlfork (je vais plutôt m'orienter vers un tableau partagé pour ne pas avoir à trop changer le code qui suit).
Merci,
-- Denis
Patrick Mevzek
En ce qui me concerne, j'utiliserai un fork ou un thread. Cela permettrai au "père" d'effectuer une tâche pendant que le fils fait l'autre. Le soucis c'est le "partage" de l'information que chacun a recolté de son côté.
Avec POE, pas de problème de partage de l'information. Cf http://poe.perl.org/
-- Patrick Mevzek . . . . . . Dot and Co (Paris, France) <http://www.dotandco.net/> <http://www.dotandco.com/>
En ce qui me concerne, j'utiliserai un fork ou un thread.
Cela permettrai au "père" d'effectuer une tâche pendant que le fils fait
l'autre.
Le soucis c'est le "partage" de l'information que chacun a recolté de
son côté.
Avec POE, pas de problème de partage de l'information.
Cf http://poe.perl.org/
--
Patrick Mevzek . . . . . . Dot and Co (Paris, France)
<http://www.dotandco.net/> <http://www.dotandco.com/>
En ce qui me concerne, j'utiliserai un fork ou un thread. Cela permettrai au "père" d'effectuer une tâche pendant que le fils fait l'autre. Le soucis c'est le "partage" de l'information que chacun a recolté de son côté.
Avec POE, pas de problème de partage de l'information. Cf http://poe.perl.org/
-- Patrick Mevzek . . . . . . Dot and Co (Paris, France) <http://www.dotandco.net/> <http://www.dotandco.com/>
