next up previous contents index
Next: 5.3 Packen und Versenden Up: 5 PVM Parallel Virtual Previous: Überblick über PVM und

Definition und Erzeugung von Kanälen

Im folgenden wollen wir das

channel ch ( tex2html_wrap_inline2808 : tex2html_wrap_inline2810 , ... tex2html_wrap_inline2812 : tex2html_wrap_inline2814 );
Sprachkonstrukt implementieren.  Die Identifikation von Kanälen erfolgt in PVM zum einen mittels einer sogenannten Taskid (tid) und zum anderen mittels eines sog. Message Tags (msgtag).

Eine taskid  wird jeder PVM task  ( tex2html_wrap_inline2816 Unix Prozeß) bei der Erzeugung oder bei der Registrierung  zugeordnet. Damit ist eine eindeutige Bezeichnung von Sendern und Empfängern von Nachrichten möglich. Ein msgtag  wird bei send und receive benutzt, um zwischen mehreren Kanälen zwischen Sendern und Empfängern unterscheiden zu können. Die msgtags sind frei wählbar. Ein Kanal könnte somit durch folgenden Datentyp beschrieben werden.

       TYPE chan = RECORD
                   tid: int;                (32 bit integer)
                   msgtag: int;             (   "          )
                   v1: t1; ...; vn: tn;
                   END;

Da die msgtags von der Anwendung frei wählbar sind, bleibt noch die Bestimmung der taskid. Dazu stehen die PVM-Funktionen mytid, parent und spawn mit den folgenden Spezifikationen zur Verfügung:

int pvm_mytid ( ); 
Bestimmung der eigenen Taskid und Registrierung beim PVM Daemon, falls noch
nicht erfolgt.

int pvm_parent ( );
Bestimmung der Taskid der Eltern Task. 

int pvm_exit ( );
Verlassen von PVM, d.h. Beenden der Verbindung zum PVM Daemon.

int pvm_spawn ( char *file;
                char * argv[];
                int flags;
                char *where;
                int count;
                int tids[] );
Erzeugen von neuen PVM tasks.
    

Spawn erzeugt count-viele neue Unix-Prozesse vom Programm file mit Argumenten argv auf Rechnern / Architekturen where mit Flags flags. In dem Array tids werden die Taskids aller erzeugten Tasks zurückgeliefert, die Anzahl der erfolgreichen Tasks ist der Funktionsrückgabewert.

Wichtig für die Erzeugung neuer Tasks ist der file Parameter, der den Dateinamen des Unix-Prozesses angibt, der gestartet werden soll. Die Datei wird in

                $PVM_ROOT/bin/$PVM_ARCH
gesucht bzw. in den Directories, die bei der Konfiguration der virtuellen Maschine mit dem `ep=' Parameter spezifiziert werden. Der Default für $PVM_ROOT ist $HOME/pvm3 und $PVM_ARCH die entsprechende Architektur. Die Parameter, die der i-ten Task übergeben werden, stehen in argv[i].

Mit Hilfe der `flags' und dem Parameter `where' kann festgelegt werden, ob die Task auf einen beliebigen Rechner (innerhalb der virtuellen Maschine), auf Rechnern einer bestimmten Architektur oder auf explizit genannten Rechnern gestartet werden sollen.

Das Array `tids' enthält nach Beendigung von Spawn die Taskids der erzeugten Tasks bzw. den jeweiligen Fehlercode, falls eine bestimmte Task nicht erzeugt werden konnte. Der spawn-Funktionswert ist die Anzahl der erfolgreich gestarteten Tasks.

Eine mögliche Implementierung wäre somit durch die Deklaration der Datentypen task und channel zusammen mit taskinit und chaninit.

        TYPE task = RECORD
                    tid: int; 
                    flag: int;
                    file, arg, where: string;
                    END;
        TYPE channel = RECORD
                       t: task
                       msgtag: int;
                       mode: int;
                       END;

        PROCEDURE taskinit (VAR t: task);
        BEGIN 
              (* initialize fields *) 
               mytid:= pvm.mytid();
               IF pvm_parent THEN t.tid:= parent.
                             ELSE pvmspawn (t.file,...)
                                            t.tid:= ... END
        END taskinit;

        PROCEDURE chaninit (VAR ch: channel; t: task; no: init);
        BEGIN ch.t:=t;
              ch.msgtag:= no;
              ch.mode:= PVMDataDefault;
        END chaninit.
taskinit erzeugt entweder eine neue PVM Task oder es stellt die Verbindung zur Elterntask her. (1 Level).  

Damit würde

channel aus (v: INTEGER);
channel ein (v: INTEGER);
zum Beispiel als
               
       VAR t:task;
           aus: channel;
           ein: channel;
               
       taskinit(t);
       chaninit(aus, t, 1);
       chaninit(ein, t, 2);
implementiert.


next up previous contents index
Next: 5.3 Packen und Versenden Up: 5 PVM Parallel Virtual Previous: Überblick über PVM und

parallel@rz.uni-mannheim.de
Mon Okt 28 14:38:25 PST 1996