Kommunikation über Pipes
|
Perl bietet mehrere Möglichkeiten zur Kommunikation zwischen Parent und
Childs.
Hier werden Pipes vorgestellt, direkte 'Schläuche' oder 'Röhren'
für die zu transportierenden Daten.
Wie für
→ Input/Output allgemein üblich, ist eine Deklaration erforderlich,
ähnlich einer open-Anweisung: Damit wird jeweils ein
Paar von Pipes erzeugt und mit Handle-Variablen
verknüpft. Es ist üblich, diese Variablen mit Großbuchstaben
zu bezeichnen.
▶
Anweisung pipe erzeugt je einen (uni-direktionalen)
Kanal zum Lesen und zum Schreiben.
Danach können die Pipes von Parent und allen Childs verwendet werden.
|
Wichtig: (Pipe)-Handles werden
beim ↑
fork-Prozess im Gegensatz zu allen anderen Variablen
nicht kopiert.
Es gibt daher für jede pipe-Anweisung nur ein
eindeutiges Paar von Kanälen.
Das Parent-Programm kann daher mittels Pipe nicht einem bestimmten Child
selektiv 'zuhören' sondern nur allen Childs gleichzeitig.
Das ist für parallele Prozesse sinnvoll, denn andernfalls braucht man
keine Child-Prozesse, sondern arbeitet sequentiell. Um ein bestimmtes Child
zu in einer Meldung bezeichnen, deklariert es am besten in den
übergebenen Daten selbst seine Identität.
|
Standard-Kanäle
Die →
I/O-Kanäle STDIN, STDOUT, STDERR sind ohne
besondere Maßnahmen in jedem Programm geöffnet.
Sie werden beim fork ausnahmsweise
nicht in den Child-Prozess kopiert, d.h. der
Parent-Prozess und jeder erzeugte Child-Prozess verwenden die gleichen
Standard-Kanäle.
|
Alle hier vorgestellten Beispiele sind Konsolen-Programme, d.h.
alle print-Anweisungen geben Text an das gleiche
Konsolen-Fenster aus.
Parent und alle Childs arbeiten gleichzeitig und unabhängig voneinander,
daher stammen die Ausgabe-Texte in bunter Mischung aus allen Prozessen.
Daher ist die Reihenfolge der Ausgabe-Texte weitgehend unbestimmt !
|
Pipe
•
Mit Anweisung pipe wird ein Paar von Kanälen
zum Lesen (PREAD) und Schreiben
(PWRITE) geöffnet. Auch diese beiden Handles
werden beim fork nicht
in den Child-Prozess kopiert.
•
Das Parent-Programm hat zunächst keine andere Aufgabe, als Child-Prozesse
zu erzeugen. Hier dokumentiert es zusätzlich deren PID-Nummern.
•
Jedes Child-Programm führt seine eigentliche Aufgabe aus
(mit #... angedeutet) und sendet allfällige
Meldungen (rot) an den Parent.
•
Vor dem Ende des Child-Programms muss der verwendete Kanal geschlossen werden.
•
Nach Erzeugung aller Child-Prozesse liest das Parent-Programm (hier in
einer while-Schleife) alle eintreffenden Meldungen.
|
Meldungen Child-Prozesse → Parent (vereinfacht !):
pipe(PREAD,PWRITE);
PWRITE->autoflush(1);
$cc = 0;
for($i=0;$i<3;$i++) {
$cpid[$cc] = fork();
if($cpid[$cc]) {
# Parent
print "-p: \$cpid[$cc]=".$cpid[$cc]."\n";
$cc++;
}
else {
# Child
print "-c$cc pid=$$\n";
close PREAD;
# ...
print PWRITE "-c$cc send\n";
# ...
close PWRITE;
exit 0;
}
}
# Parent read loop
close PWRITE;
while (chomp( $msg = <PREAD>)) {
print "-p read: $msg\n";
}
close PREAD;
|
Anmerkungen:
•
Anweisung autoflush sorgt nach jeder
einzelnen print-Anweisung für die sofortige
Übertragung der Daten dieses Kanals (andernfalls werden die Daten
gespeichert und in größeren Blöcken gesendet).
•
Nicht benötigte Kanäle werden vor der
Kommunkation geschlossen (close PREAD von jedem Child),
benutzte Kanäle nach der Kommunikation
(close PWRITE von jedem Child am Ende seines Programms.
Wenn der PWRITE-Kanal von einem einzigen Child
nicht geschlossen wird, dann entkommt das Parent-Programm nicht aus seiner
(unendlichen) Lese-Schleife !
|
•
In seiner Lese-Schleife erhält das Parent-Programm die
auf <PREAD> eintreffenden Meldungen aller Childs.
Dabei wird keine Reihenfolge eingehalten, d.h. die Daten können von jedem
Child stammen.
Im Beispiel markiert jedes Child seine Meldung mit seiner fortlaufenden Nummer
($cc), alternativ mit seiner
PID-Nummer $$.
•
Das Beispiel funktioniert, muss jedoch für die Praxis abgesichert werden:
Ein ↑ Timeout
muss sicherstellen, dass nach Ablauf einer sinnvollen Arbeitszeit die
Lese-Schleife verlassen wird und alle noch aktiven Childs
(mit kill)
beendet werden. (→ nachfolgende Beispiele).
•
Wenn eine bidirektionale Kommunikation gewünscht wird, dann öffnet man
mit einer weiteren pipe-Anweisung ein zusätzliches
Paar von Kanälen. In diesem Fall kann man auch Meldungen vom Parent an die
(noch aktiven) Childs senden. Das ist nur dann notwendig, wenn die Daten erst
nach dem fork-Prozess vorliegen.
Normalerweise wird ein Child bereits bei der Erzeugung mit allen Daten zu seiner
Steuerung versorgt. Dazu genügt es, den betreffenden Variablen
vor dem fork Werte zuzuweisen.
|
Modul IO
Dieses Perl-Modul bietet zahlreiche spezialisierten Funktionen für
versierte EntwicklerInnen.
Hier wird lediglich das Sub-Modul IO::Pipe vorgestellt. Das Beispiel arbeitet
genauso wie das oben vorgestellte Beispiel.
Weitere Funktionen bieten u.a. die Möglichkeit für non-blockin Pipes.
In diesem Fall wird das Lesen von einem Pipe-Kanal nicht
blockiert, wenn der Kanal nicht bereit ist.
|
Meldungen Child-Prozesse → Parent (vereinfacht !):
use IO::Pipe;
my $pipe=new IO::Pipe;
$cc = 0;
for($i=0;$i<3;$i++) {
$cpid[$cc] = fork();
if($cpid[$cc]) {
# Parent
print "-p: \$cpid[$cc]=".$cpid[$cc]."\n";
$cc++;
}
else {
# Child
print "-c$cc pid=$$\n";
$pipe->writer();
$pipe->autoflush(1);
# ...
print $pipe "-c$cc send\n";
# ...
exit 0;
}
}
# Parent read loop
$pipe->reader();
while (chomp( $msg = <$pipe>)) {
print "-p read: $msg\n";
}
undef $pipe;
|
Private Kanäle
Wenn beliebige
→ I/O-Kanäle nach
dem fork-Verzweigung geöffnet werden,
dann dienen sie dem jeweiligen Programm-Teil als exklusive private Kanäle.
|
Wenn z.B. im Child Programm-Teil eine Datei zum Lesen oder Schreiben
geöffnet wird
open(READ,'test.dat');
dann benutzt jeder Child-Prozess mit dem Handle READ
seinen eigenen Kanal, meist zu unterschiedlichen Dateien. Jeder Child-Prozess
sollte offene Kanäle nach Verwendung unbedingt schließen.
|
Non-Blocking
Ohne weitere Maßnahmen sind alle I/O-Anweisungen
(<KANAL>-Zuweisung, print)
'Blocking', d.h. jede I/O-Anweisung wartet mit der Ausführung, bis der
entsprechende Kanal 'ready' meldet.
Dieses Verhalten kann ein Programm lahmlegen, wenn der Kanal niemals bereit
(fertig) wird.
Dieser Fall tritt bei Child-Prozessen öfters auf. Dagegen helfen 2
übliche Strategien:
•
Blockierte Child-Prozesse durch das Parent-Programm abbrechen
(↓ folgendes Beispiel).
•
Kanal 'Non-Blocking' setzen (rechts).
|
use IO::Handle;
$io = new IO::Handle;
pipe(PREAD,PWRITE);
$cc=0;
for $i (0..3) {
$cpid[$cc] = fork();
if($cpid[$cc]) {
# Parent
print "-p: \$cpid[$cc]=".$cpid[$cc]."\n";
$cc++;
}
else {
# Child
close PREAD;
$io->fdopen(fileno(PWRITE),'w');
$io->autoflush (1);
$w = int(rand(5));
$io->print("-c$cc: wait $w\n");
print "-c$cc: wait $w\n";
sleep($w); # Simul.Arbeitszeit
$io->print("-c$cc: finished\n");
$io->close;
exit 0;
}
}
# Parent
close PWRITE;
sleep(1);
kill(9,@cpid);
$io->fdopen(fileno(PREAD),'r');
$io->blocking(0);
while(chomp($msg=$io->getline)) {
print "-p read: $msg\n";
}
$io->close;
close PREAD;
|
Das Beispiel zeigt eine Variante des mit ↑ Pipe
gezeigten Beispiels am Anfang dieses Kapitels. Der Code wurde möglichst
wenig modifiziert.
Zunächst wird ein Handle ($io) erzeugt, dem
später mit fdopen die Pipe-Kanäle zugewiesen
werden, und zwar PWRITE in den Child-Prozessen
und PREAD im Parent-Prozess.
Jeder Child-Prozess sendet 2 Meldungen ('wait', 'finished'), dazwischen
wird eine zufällige 'Arbeitszeit' simuliert.
Der Parent-Prozess wartet (sleep) 1 Sekunde und beendet
danach (kill) alle noch arbeitenden Child-Prozesse.
Der Eingangs-Kanal kann mit $io->blocking(0)
non-blocking gesetzt werden.
|
Das Beispiel verhält sich - wie einige dieser Seite - je nach System
unterschiedlich:
Linux:
•
Anweisung $io->blocking(0) funktioniert.
Der Lese-Vorgang wird durch noch laufende Child-Prozesse nicht mehr blockiert.
•
Mit kill(9,@cpid) werden alle noch laufenden
Child-Prozesse beendet. Auch das genügt, um die Blockierung des Pipe-Kanal
aufzuheben.
Spätestens am Ende des Parent-Programms sollten damit alle noch laufenden
Zombies beendet werden.
|
Windows:
•
Anweisung $io->blocking(0) funktioniert derzeit nicht.
Der Lese-Vorgang wird durch jeden noch laufenden Child-Prozess blockiert.
•
Mit kill(9,@cpid) werden alle noch laufenden
Child-Prozesse beendet. Das genügt normalerweise, um die Blockierung
des Pipe-Kanal aufzuheben.
|
Zu viele erzeugte Prozesse können jedes System lahmlegen !
Perl
Es ist verwirrend, dass