[Informatik-Fachberichte] Parallele Implementierung funktionaler Programmiersprachen Volume 232 ||...

Kapitelll

Verwaltung der Parallelitat

Jede Parallelverarbeitung ist mit einem zusatzlichen Organisationsaufwand verbunden, der durch die notwendige Kommunikation und Synchronisation zwischen den unabhangig arbeitenden Einheiten entsteht. In unserer parallelen abstrakten Maschine wird diese Organisationsarbeit soweit wie moglich von den Kommunikationseinheiten geleistet, damit der ReduktionsprozeB, also die Programmausfiihrung moglichst wenig durch die Parallelisierung behindert wird. Die von den Reduktionsarbeiten zu leistende Mehrarbeit besteht aus der Annahme von Antwort- und Aktivierungsnachrichten sowie cler Beantwortung von Anfragenachrichten. Zur Bearbeitung dieser Nachrichten sind Zugriffe auf die Graphkomponente im lokalen Speicher der Reduktionseinheit erforderlich. Eine Auslagerung dieser Arbeiten in die Kommunikationseinheiten wiirde erfordern, daB der Graph im gemeinsamen Speicher von Kommunikations- und Reduktionseinheit liegt. Dies wiirde allerdings die Zugriffsmoglichkeiten der Reduktionseinheit auf den Graphen erheblich beschranken. Da der gesamte ReduktionsprozeB durch die im Graphen abgelegten Informationen gesteuert wird und somit fast jede Zustandstransformation der Reduktionseinheit einen Zugriff auf den Graphen erfordert, verzichten wir auf eine vollstandige Auslagerung der Verwaltung der Parallelitat in die Kommunikationseinheiten.

Wir beginnen in diesem Kapitel mit der Beschreibung der Nachrichtenverwaltung in den Reduktionseinheiten. Sodann wenden wir uns der Spezifikation der Kommunikationseinheiten zu und beschlieBen dieses Kapitel mit der formalen Beschreibung der gesamten parallelen abstrakten Maschine als nichtdeterministisches Transitionssystem.

R. Loogen, Parallele Implementierung funktionaler Programmiersprachen© Springer-Verlag Berlin Heidelberg 1990

11.1. NACHRICHTENVERWALTUNG - REDUKTIONSEINHEITEN 317

11.1 N achrichtenverwalt ung in den Red uktionseinheiten

Die Nachrichtenbearbeitung erfolgt in den Reduktionseinheiten im Kommunikationsmodus, in den sofort, wenn eine Nachricht von der Kommunikationeinheit in die Nachrichtenschlange des gemeinsamen Speichers geschrieben wird, gewechselt wird. Vier verschiedene Arten von Nachrichten werden in der abstrakten Maschine zwischen den Reduktionseinheiten ausgetauscht - Prozefinachrichten, Anfrage-, Aktivierungs- und Antwortnachrichten (siehe Definition 10.3.5)

Eine Prozepnachricht wird nur dann von der Kommunikationseinheit an die Reduktionseinheit weitergeleitet, wenn das Prozefianforderungsflag im gemeinsamen Speicher von der Reduktionseinheit gesetzt wurde. Die Kommunikationseinheit setzt das Flag immer, wenn sie eine Nachricht an die Reduktionseinheit schickt oder weiterleitet, zuriick, da jede Nachricht zur Aktivierung oder Reaktivierung lokaler Tasks fiihren kann. Dies bedeutet, dafi die Reduktionseinheit beim Erhalt einer Prozefinachricht auf jeden Fall im Wartemodus ist. Je nachdem, ob der in der Nachricht beschriebene Prozefi global oder lokal ist (d.h. eine globale oder lokale Heimatadresse hat), wird ein neuer aktiver Taskknoten generiert oder der existierende Verweisknoten mit einem Taskknoten iiberschrieben. Der 'active task pointer' wird mit der Adresse des Taskknoten belegt. Der Kommunikationsmodus bleibt zunachst bestehen. Erst wenn keine weitere Nachricht im Nachrichtenpuffer enthalten ist, wird in den Reduktionsmodus gewechselt.

Bei der Bearbeitung einer A nfragenachricht iiberpriift der Reduktionsprozessor zunachst den Graphknoten, auf den sich die Anfrage bezieht. Handelt es sich urn einen Terminalknoten, so kann die Anfragenachricht sofort beantwortet werden. Anderenfalls mufi die Beantwortung solange verzogert werden, bis die Auswertung des entsprechenden Teilgraphen bis zur Kombinatornormalform abgeschlossen ist. Dies geschieht, indem die Adresse, an die die Antwort geschickt werden solI, in der Liste der globalen Adressen des in Auswertung befindlichen Task- oder Verweisknoten notiert wird. Natiirlich ist es moglich, dafi die Auswertung erst durch die Anfragenachricht, die ja insbesondere einen Auswerter enthalt, angestofien wird.

1st die Anfragenachricht an einen Verweisknoten gerichtet, dessen globale Adresse bekannt ist, so wird sie an diese globale Adresse weitergeleitet, damit die Beantwortung der Anfrage in direkter Weise erfolgen kann.

Eine Aktivierungsnachricht hat denselben Effekt wie die Ausfiihrung einer INIT ARG- oder INITLOC-Instruktion. Schlafende Taskknoten werden indirekt parallel aktiviert. Argumentknoten werden lokal aktiviert. In aktiven Taskknoten und Verweisknoten ohne Adressenangabe wird gegebenenfalls der Auswerter

318 KAPITEL 11. VERWALTUNG DER PARALLELITAT

erhoht. Fiir Datenstrukturknoten, deren Auswerter erhoht wird, erfolgt ein entspreehender Eintrag in der Aktivierungsliste.

Eine A ntwortnachricht hat zunaehst zur Folge, dafi der 'pending count' aller in der lokalen Adressenliste des adressierten Verweisknotens vermerkten Taskknoten dekrementiert wird und dafi die Antwortnachricht an alle in der globalen Adressenliste vermerkten Adressen weitergeleitet wird. Wird der 'pending count' einer lokalen Task dureh das Dekrementieren zu Null, so wird die Adresse der Task in die lokale Taskwarteschlange geschrieben. Zuletzt wird der Verweisknoten mit dem in der Antwortnaehricht enthaltenen Terminalknoten iibersehrieben.

11.1.1 Definition 1m Kommunikationsmodus sind fiir die j-te Reduktionseinheit RE j folgende Zustandsiibergange moglich:

1. Bearbeitung einer Prozepnachricht

( (em, nil, G, gp, €, €, ps), ([PROCESS, F, arglist, ~, art, hadr]: red-q, eom-q, false) )

I- G[gp/([TASK,F,arglist, (~,ea-e(F,~,art),€, €, 0, €,hadr))], {((em, gp,

RE, gp+l, €, €, ps), (red-q, eom-q, false) )

falls hadr ¢ {(j, ladr) Iladr E LAdr}

G[ladr/([TASK,F,arglist,(t', ea-e(Fl',art),€, €,O,lq,gq ))], {((em,ladr,

gp, €, €, ps), (red-q, eom-q, false))

falls hadr = (j, ladr) G(ladr) = (INDIRECTION, ?, t, lq, gq) und €, = max{C,€},

wobei ps = ( ea-e, ea-f, rg, e-evt, e ) sei.

2. Bearbeitung einer A nfragenachricht

( (em, atp, G, gp, ltq, al, ps), ([REQUEST, (j, ladr), ~, gadr]:red-q, eom-q, false) )

I- {((em, atp, G, gp, ltq, al, ps), RE, (red-q, eom-q: [ANSWER, gadr, G(1adr)], false) )

falls G(ladr) E Terminalnodes, aber G(ladr) ist nieh! Strukturdatenknoten mit Auswerter ~ < ~.


{ ((em, atp, G[ladr/(SDATA, c, arglist, ~)],

I- gp, ltq, al: (ladr, e-evt(c,~)), ps), REJ (red-q, eom-q: [ANSWER, gadr, (SDATA, c, arglist, ~)],

false) )

~RE, {

falls G(ladr) = (SDATA, c, arglist, () mit ( < ~, ps=(ea-e,ea-f,rg,e-evt,e).

((em, atp, G[ladr/(INDIRECTION, ?, ~, E, gadr)], gp, ltq, al, ps),

(red-q, eom-q: [PROCESS,F,arglist,~,indir,(j,ladr)l, false) ) falls G(ladr) = (TASK, F, arglist, ~o)

{((em, atp, G[ladr/(TASK,arg,arglist'(~i' Ii, E,lv,O,E,gadr))],

gp, ltq: ladr, al, ps), (red-q, eom-q, false) ),

falls G(ladr)= (ARGUMENT, (arglist,lv) ,(It , 12 , 13 ))

und ~ = ~i mit i E {1,2,3}.

{

((em, atp, G[ladr/(TASK, IL, arglist, (€', ip, ds, lv, pe, lq, gq: gadr)], gp, Itq, aI, ps),

(red-q, eom-q, false) ),

~RE, {

falls G(ladr) = (TASK, IL, arglist, ((, ip, lv, pe, lq, gq ))

und €':= max{(,~}.

((em, atp, G[ladr/(INDIRECTION, ?, (', lq, gq: gadr)], gp, ltq, al, ps),

(red-q, eom-q, false) ), falls G (ladr) =

(INDIRECTION, ?, (, lq, gq) und €' = max{(,O.

((em, atp, G[ladr/(INDIRECTION, adr, t', lq, gq)], gp, Itq, aI, ps),

(red-q, eom-q: [REQUEST,adr'(',gadr], false) ), falls G(ladr) =

(INDIRECTION, adr, t, lq, gq) mit adr f. ? und €' = max{~,€}.


r {((em, atp, G, gp, hq, aI, ps), RE, ([REQUEST, (j, ladr'), ~, gadr]: red-q, eom-q, false) ),

falls G(ladr) = (LOCAL-IND, ladr').

3. Bearbeitung einer Aktivierungsnachricht

( (em, atp, G, gp, hq, aI, ps), ([INITIATE, (j, ladr'), ~]: red-q, eom-q, false) ),

((em, atp, G, gp, hq, aI, ps), (red-q, eom-q, false) ),

falls G(ladr) E Terminalnodes, aber G(ladr) ist nicht Strukturdatenknoten mit Auswerter ~ < ~.

{((em, atp, G[ladr/(SDATA, c, arglist, ~)],

rRE, gp, hq, al: (ladr, e-evt(c,O), ps), (red-q, eom-q, false) )

~RE, {

falls 9(ladr) = (SDATA, c, arglist, ~) mit ~ <~, ps = ( ea-e, ea-f, rg, e-evt, e ).

((em, atp, G[ladr/(INDIRECTION, ?, ~, €, E)], gp, hq, al, ps),

(red-q, eom-q: [PROCESS,F,arglist,~,indir,(j,ladr)], false) ) falls G(ladr) = (TASK, F, arglist, ~o).

{((em, atp, G[ladr/(TASK, arg, arglist, (~i,li,€,lv,O,€,€))],

rRE, gp,ltq: ladr, aI, ps), (red-q, eom-q, false) ),

falls G (ladr) = (ARGUMENT,(arglist,lv),(h, 12 , 13 ))

und ~ = ~i mit i E {1,2,3}.

{((em, atp, G[ladr/(TASK,jl,arglist,(~', ip, ds, lv, pe, lq, gq)],

rRE, gp, hq, aI, ps), (red-q, eom-q, false) ),

falls G(ladr) = (TASK, jl, arglist, (~, ip, lv, pe, lq, gq))

und ~, := max{~,~}


((cm, atp, G[ladr/(INDIRECTION, adr, e', lq, gq)), gp, ltq, al, ps),

(red-q, com-q, false) ), falls G (ladr) =

(INDIRECTION, adr, e, lq, gq) mit (adr = ? oder ~ ~ e) und e' = max{e,O·

((cm, atp, G[ladr/(INDIRECTION,adr,~,lq,gq)), gp, ltq, aI, ps),

(red-q, com-q:[INITIATE,adr,~), false) ), falls G (ladr) =

(INDIRECTION, adr, e, lq, gq) mit adr "I ? und ~ > {

f- {((cm, atp, G, gp, ltq, al, ps), REJ ([INITIATE, (j, ladr'), ~): red-q, com-q, false) ),

falls G(ladr) = (LOCAL-IND, ladr').

4. Bearbeitung einer Antwortnachricht

((cm, atp, G[ladr/ (INDIRECTION, adr', e, ladrl ... ladr[, gadr1 ... gadrk)), gp, ltq, aI, ps),

([ANSWER, (j, ladr), tnode): red-q, com-q, false) )

((cm, nil, G[ladr /tnode,

ladrl/(TASK,/Ll, arglist1, (e, iPl' ds1, IV1,PC1 - 1, lql' gql))'

ladrl/(TASK,/L[, arglist[, (e, ip[, ds[, lVI, pc[ - 1, lq[, gq[))), gp, ltq: ladril" .ladrim' al, ps),

(red-q, com-q: [ANSWER, gadrl' tnode') ...

mit tnode' = {

[ANSWER, gadrk' tnode')' false) ) (SDATA, c, arglist, e)

falls tnode = (SDATA, c, arglist, ~) mit ~ < e

tnode sonst. und G(ladrd = (TASK, /Li,arglisti,(e,pi,dsi,lvi,pci,lqi,gqi))

mit pCi > 0 (1 ~ i ~ l) und {iadrill" ., ladrim} :=

{ladri 11 ~ i ~ l,pci = ~ladr.(ladrl" . 1adrl)} ,


wobei ~ladr. (ladrl ... ladrm ) die Anzahl der Vorkommen von ladri in ladrl ... ladrt bezeichne, und

{ al: (ladr, c-evt( c, ~)) falls ~ > e und

aI' := tnode=(SDATA,c,arglist', ~), al sonst.

5. Riickkehr in den Reduktionsmodus

( (em, atp, G, gp, ltq, aI, ps), (E, com-q, false) ) f-REJ ((rm, atp, G, gp, ltq, aI, ps), (E, com-q, false) )

Die Arbeit, die von der Reduktionseinheit im Kommunikationsmodus geleistet wird, entspricht dem Mehraufwand, der auf der sequentiellen Ebene fUr die Parallelisierung aufgebracht werden muB. Wie man leicht an Hand der Definition der Ubergangsrelation f-REJ (1 ~ j ~ n) iiberpriift, arbeitet jede Reduktionseinheit deterministisch.

11.1.2 Lemma Fiir j E {I, ... ,n} ist REj ein deterministisches Transitionssystem d.h. zu jedem st E L8tRE x 8M gibt es hOchstens ein st' E L8tRE x 8M, so daB gilt:

st f-REJ st'.

Damit schlieBen wir die formale Spezifikation der Reduktionseinheiten ab und wenden uns den Kommunikationseinheiten zu.

11.2 Der Kommunikationsprozessor

In Abschnitt 9.2 haben wir bereits einen Uberblick iiber den Aufbau und die Aufgaben der Kommunikationseinheiten gegeben. Jede Kommunikationseinheit besteht aus zwei Prozessoreinheiten - dem Netzwerkadapter und dem Kommunikationsprozessor, die wiederum iiber einen gemeinsamen Speicherbereich Nachrichten austauschen konnen.

Wie schon die Reduktionseinheiten spezifizieren wir auch die Prozessoreinheiten der parallelen Ebene als Transitionssysteme. Wir beginnen in diesem Abschnitt mit der formalen Beschreibung des Kommunikationsprozessors, dessen Hauptaufgabe die Verteilung der parallelen Prozesse und damit verbunden der dynamische Ausgleich der Arbeitslasten ist. Urn zu entscheiden, welche Prozesse an welche Prozessorelemente verteilt werden, benotigt der Kommunikationsprozessor Informationen iiber die Topologie des Verbindungsnetzwerkes, die Arbeitslast anderer Prozessoreinheiten und selbstverstandlich seine eigene Auslastung. Da wir in der parallelen Maschine von der Topologie des Verbindungsnetzwerkes abstrahieren,

11.2. SPEZIFIKATION DES KOMMUNIKATIONSPROZESSORS 323

werden wir auch keinerlei Annahmen und Aussagen iiber den eigentlichen AIgorithmus, der zur Prozefiverteilung eingesetzt wird, machen. Wir beschreiben also lediglich die organisatorischen Aspekte und die prinzipielle Arbeitsweise des Kommunikationsprozessors.

Der Kommunikationsprozessor hat auf drei separate Speicherbereiche Zugriff (siehe Bild 11.1):

• auf den gemeinsamen Speicher mit der Reduktionseinheit,

• auf seinen lokalen Speicherbereich und

• auf den gemeinsamen Speicher mit dem Netzwerkadapter.

Der lokale Speicherbereich enthalt im wesentlichen zwei Komponenten:

• eine Warteschlange fiir Prozesse und

• Informationstabellen.

Ein lokaler Zustand des Kommunikationsprozessors hat also die Form

( pq, inftab ),

wobei pq fiir die Prozefiwarteschlange (process queue) und inftab fiir die Informationstabellen steht.

Die Prozepschlange enthalt aktivierte, aber noch nicht gestartete parallele Prozesse, in Form von Prozefinachrichten. Diese Prozesse sind zur AusfUhrung in der Reduktionseinheit bestimmt. Auf Grund des dynamischen Arbeitslastenausgleichs ist es aber moglich, dafi Prozesse aus der Warteschlange zu anderen Prozessorelementen geschickt werden. Aus diesem Grunde befindet sich die Warteschlange mit den noch nicht gestarteten Prozessen in dem lokalen Speicherbereich des Kommunikationsprozessors und nicht etwa im Speicher der Reduktionseinheit.

Alle noch nicht gestarteten Prozesse bleiben auf diese Weise solange wie moglich verlagerbar. Zur Vereinfachung sehen wir in der abstrakten Maschine davon ab, Prozesse, deren Ausfiihrung begonnen wurde, auf andere Prozessorelemente zu verlagern. Dies erscheint uns nur in Ausnahmesituationen sinnvoll, auf deren Behandlung wir auf dem Level der abstrakten Maschine verzichten mochten.

Die AusfUhrung eines parallelen Prozesses wird in der abstrakten Maschine also immer in der Reduktionseinheit beendet, in der sie begonnen wird. Unter Beginn der Ausfiihrung verstehen wir dabei natiirlich nicht die Aktivierung eines Prozesses, sondern den Zeitpunkt, an dem fUr den Prozefi ein aktiver Taskknoten erzeugt wird.

324

Inports 1 1 I

Netzwerk-

adapter

Kommunika-

tions- i----"'

prozessor

Reduktions-

prozessor ..----.

KAPITEL 11. VERWALTUNG DER PARALLELITAT

Outports

i

* Eingabe-schlange

~

I

~ Red.-

schlange

1 Zeiger auf aktive Task

Programm-speicher

1

i t

Ausgabe- Prozefi-schlange warte-

schlange

i t

Informationstabellen I

Kom.- D schlange Flag zur

D Prozefi-anforderung

Arbeits-modus

Graph

* 11\1 (

~ ~ lokale Task-

I I l I I warte-"- schlange

1 * I

-I Aktivierungsliste -

K o M M U N I K A T I o N S E I N H E I T

R E D U K T I o N S E I N H E I T

Bild 11.1: Gesamtzustandsraum eines Prozessorelementes

11.2. SPEZIFIKATION DES KOMMUNIKATIONSPROZESSORS 325

Zu den In/ormationstabellen ziihlen wir aIle Komponenten und Strukturen, die der Kommunikationsprozessor zur ProzeBverteilung benotigt. Dazu gehoren statische Informationen tiber die Vernetzung, also etwa die Anzahl und Nummern der direkten Nachbarprozessorelemente, aber auch dynamische Informationen, etwa tiber die Arbeitslast der tibrigen Prozessorelemente, sofern solche Informationen durch Kommunikation verfiigbar gemacht werden konnen.

Wie bereits gesagt, gehen wir nicht auf Arbeitsverteilungsstrategien ein. Mit Sicherheit werden die Kommunikationsprozessoren mittels spezieller Nachrichten kommunizieren, mit denen sie Informationen iiber die Arbeitslasten austauschen. Wir nennen diese Nachrichten Verwaltungsnachrichten. Ein einfaches Beispiel fUr solche Verwaltungsnachrichten sind Arbeitsanfragenachrichten, mit denen Prozessorelemente, die ohne Arbeit sind, von anderen Prozessorelementen Prozesse anfordern konnen. Kommunikationsprozessoren, die eine solche Arbeitsanfrage erhalten, konnen dann, wenn es ihnen moglich ist, Prozesse abzugeben, die Arbeitsanfrage mit einem oder mehreren Prozessen beantworten oder anderenfalls eine negative Antwortnachricht senden und/oder einen entsprechenden Vermerk in den Informationstabellen vornehmen.

11.2.1 Definition Der lokale Zustandsraum emes Kommunikationsprozessors LStcp (local store) wird definiert durch

LStcp := ProMes* x In/Tab,

wobei ProMes die Menge der ProzeBnachrichten ist (siehe Definition 10.3.5) und In/Tab eine Menge von Informationstabellen ist, die nicht weiter spezifiziert wird.

Der gemeinsame Speicher von Kommunikationsprozessor und Netzwerkadapter enthalt zwei Nachrichtenwarteschlangen zur Ein- und Ausgabe von Nachrichten. Der Zustand des Speichers hat also die allgemeine Form

( in-q, out-q ).

Die Eingabewarteschlange (in-q) wird vom Netzwerkadapter mit Nachrichten, die iiber das Netz an das Prozessorelement geschickt werden, beschrieben. Diese Nachrichten sind entweder Reduktionsnachrichten, die bis auf die ProzeBnachrichten an die Reduktionseinheit weitergeleitet miissen oder Verwaltungsnachrichten, die vom Kommunikationsprozessor selbst bearbeitet werden.

Die Eintdige in der Ausgabenachrichtenwarteschlange (out-q) sind Paare bestehend aus einer Prozessornummer und einer Nachricht. Die Prozessornummer identifiziert das Prozessorelement, an das die Nachricht geschickt werden solI. Wir bezeichnen diese Paare als Netznachrichten, da die Nachrichten in dieser Form durch die Kanale des Netzwerkes geschickt werden.


11.2.2 Definition Der gemeinsame Speicher von Netzwerkadapter und Kommunikationsprozessor SM 10 wird definiert durch:

SMIO := Inputqueue X Outputqueue,

wobei

• Inputqueue := Messages· und

• Outputqueue:= Netmes· sei.

Netmes := {I, ... , n} x Messages bezeichnet dabei die Menge der Netznachrichten (net messages) und

Messages:= RedMes U AdminMes die Menge der Nachrichten schlechthin.

Die Menge RedMes der Hauptnachrichten wurde in Definition 10.3.5 definiert.

Die Menge AdminMes der Verwaltungsnachrichten (administration messages) wird nicht weiter spezifiziert.

Die Zustandiibergange des Kommunikationprozessors sind bestimmt durch die Nachrichten, die an ihn iibermittelt werden. Das sind zum einen die Nachrichten von der Reduktionseinheit und die N achrichten von anderen Prozessorelementen. Wir werden in der Spezifikation des Prozessors keine Reihenfolge zur Bearbeitung der beiden Nachrichteneingaben vorgeben. Aus diesem Grunde ist das Thansitionssystem des Kommunikationsprozessors nichtdeterministisch.

11.2.3 Definition Sei j E {I, ... , n}.

Der j-te Kommunikationsprozessor CPj wird als Thansitionssystem

CPj:= (SM x LStcp x SMIO,f-cp"INcp,)

mit der Zustandsmenge SM x LStcp x SMIO,

der Ubergangsrelation

f-cp, ~ (SM x LStcp x SMIO ) x (SM x LStcp x SMIO )

und der Anfangszustandsmenge IN cp, ~ (SM x LStcp x SMIO)

definiert.

Die Ubergangsrelation werden wir im folgenden Abschnitt definieren.

Die Anfangszustandsmenge legen wir wie folgt fest:

IN ._ { {«(€,€,false),(€,inftab),(€,€)) I inftab E Inftab} fallsj = 1, cp,.- {«(€, €, true), (€,inftab),(€,€)) I inftab E Inftab} sonst.

11.3. NACHRICHTENVERWALTUNG 327

Die Definition der Anfangszustande ist konsistent mit der Festlegung der Anfangszustande der Reduktionseinheiten. Die Berechnung startet auf dem Prozessorelement 1, in dessen Speicher das ProzeBanforderungsfiag daher nicht gesetzt ist. AIle Nachrichtenpuffer und Warteschlangen sind zu Beginn einer Berechnung leer. Die Ubergangsrelation des Kommunikationsprozessors wird im nun folgenden Abschnitt definiert.

11.3 Verwaltung der Nachrichten im Kommunikationsprozessor

Die Nachrichten, die dem Kommunikationsprozessor von der Reduktionseinheit iibermittelt werden, miissen bis auf die ProzeBnachrichten nur in eine Netznachricht eingebettet und an den Netzwerkadapter weitergeleitet werden. Dazu wird aus der Zieladresse der jeweiligen Nachricht, die immer in der zweiten Komponente der Aktivierungs-, Anfrage- oder Antwortnachrichten gegeben ist, die Prozessornummer herausgeblendet und der Nachricht vorangestellt.

ProzeBnachrichten werden gesondert behandelt. Mittels des ProzeBverteilungsalgorithmus, den wir als Funktion

distribute: PraMes x LStcp -t {I, ... ,n} x In/Tab

vorgeben, wird zu der ProzeBnachricht unter Beriicksichtigung des lokalen Zustandes die Nummer des Prozessorelementes bestimmt, an das der ProzeB weitergeleitet werden solI. Dies kann durchaus die eigene Prozessornummer sein. In diesem Fall wird die ProzeBnachricht in die ProzeBwarteschlange geschrieben. Anderenfalls wird sie in eine Netznachricht eingebettet und in die Ausgabewarteschlange geschrieben. Die getroffene Entscheidung kann in den Informationstabellen vermerkt werden. Daher hat die Funktion distribute den Bereich der Informationstabellen als zweite Komponente in ihrem Wertebereich.

Eine spezielle Mitteilung der Reduktionseinheit an den Kommunikationsprozessor ist das Set zen des ProzeBanforderungsfiags. Wird dieses Flag gesetzt, so sendet der Kommunikationsprozessor, falls die ProzeBwarteschlange in seinem 10-kalen Speicher nicht-Ieer ist, den erst en ProzeB dieser Warteschlange an die Reduktionseinheit und setzt das Flag zuriick.

Anderenfalls bearbeitet er zunachst die Nachrichten, die von anderen Prozessorelementen geschickt worden sind, da unter diesen ProzeB- oder andere Reduktionsnachrichten sein konnen, die ebenfalls zur Aktivierung oder Reaktivierung von Berechnungen fiihren konnen. Falls auch die Eingabewarteschlange leer ist, wird anhand der in den Informationstabellen gegebenen Informationen entschieden, ob


Verwaltungsnachrichten, etwa Arbeitsanforderungsnachrichten an andere Prozessorelemente geschickt werden sollen. Wir geben diesen Entscheidungsalgorithmus wiederum als Funktion

getwork j : InfTab -+ (({I, ... , n} \ {j}) X AdminMes)* X InfTab

vor, die anhand der Informationstabellen geeignete Verwaltungsnachrichten an andere Prozessoren generiert und die Informationstabellen aktualisiert.

11.3.1 Definition "N achrichten" von der Reduktionseinheit bewirken folgende Zustandsiibergange des j-ten Kommunikationsprozessors (1 ::; j ::; n):

1. Bearbeitung von Anfrage-, Antwort- oder Aktivierungsnachrichten

( (red-q, mes:com-q, next), (pq, inftab), (in-q, out-q) } rcP) ( (red-q, com-q, next), (pq, inftab), (in-q, out-q:[pnr, mes]) }

falls mes E RedMes \ ProMes und proj2(mes) = (pnr, ladr) E GAdr.

2. Verteilung von Prozessen

( (red-q, pmes:com-q, next), (pq, inftab), (in-q, out-q) }

I-cPJ

((red-q, com-q, next), (pq:pmes, inftab'), (in-q, out-q)} falls pmes E ProMes und distribute(pmes, (pq, inftab)) = (j, inftab'),

((red-q, com-q, next), (pq, inftab'), (in-q, out-q:[pnr, pmes])} falls pmes EProM es und distribute(pmes, (pq, inftab)) = (pnr, inftab'). mit pnr =I j

Die Funktion

distribute: ProMes xLStcp -+ {l, ... ,n} X InfTab

repdisentiert dabei den Algorithmus zur Prozefiverteilung, von dessen spezieller Struktur abstrahiert wird.

3. Weiterleiten eines Prozesses an die Reduktionseinheit

( (f, com-q, true), (pmes:pq, inftab), (in-q, out-q) } rcp; ( (pmes, com-q, false), (pq, inftab), (in-q, out-q) }

11.3. NACHRICHTENVERWALTUNG 329

4. Reaktion auf fehlende A rbeit

( (E,E, true), (E, inftab), (E, out-q) ) I-cp, ( (E, E, true), (E, inftab'), (E, out-q:mesl : ... : mesk) ),

wobei (mesl : ... : meSk, inftab') := getworkj(inftab), also k ~ 0, mesi E ({I, ... , n} \ {j}) x AdminMes.

Aktivierungs-, Antwort- und Anfragenachrichten von anderen Prozessorelementen werden vom Kommunikationsprozessor lediglich an die Reduktionseinheit weitergeleitet, d.h. in die entsprechende Nachrichtenschlange des gemeinsamen Speicher geschrieben. Das Weiterleiten einer Nachricht an die Reduktionseinheit fiihrt immer zum Zuriicksetzen des Prozefianforderungsflags, da Aktivierungs- und Anfragenachrichten Argumentberechnungen aktivieren konnen und Antwortnachrichten zur Reaktivierung suspendierter Tasks fiihren konnen.

Prozefinachrichten werden La. in die Prozefiwarteschlange geschrieben. Nur wenn das Prozefianforderungsflag gesetzt ist, wird eine Prozefinachricht direkt an die Reduktionseinheit weitergeleitet.

Verwaltungsnachrichten werden vom Kommunikationsprozessor verarbeitet. Zur Spezifikation geben wir eine allgemeine Funktion

handle-admin-message: AdminMes x LStcp --+ ({I, ... ,n} x Messages)* x LStcp

vor, die zu einer Verwaltungsnachricht und einem lokalen Zustand eine Folge von Netznachrichten und einen Folgezustand angibt.

Zum Beispiel konnte diese Funktion zu einer Arbeitsanfragenachricht aus der Prozefiwarteschlange eine Prozefinachricht wahlen und diese als Antwort auf die Arbeitsanfrage senden.

11.3.2 Definition "Nachrichten" von anderen Prozessorelementen bewirken folgende Zustandsiibergange des Kommunikationsprozessors

1. Bearbeitung von externen Arbeits-, Anfrage- und Aktivierungsnachrichten:

( (red-q, com-q, next), (pq, inftab), (mes: in-q, out-q) } I-cp, ( (red-q, mes:com-q, false), (pq, inftab), (in-q, out-q) }

falls mes E RedMes \ ProMes.

2. Bearbeitung von externen Prozepnachrichten

( (red-q, com-q, next), (pq, inftab), (pmes:in-q, out-q) )

{

(( red-q, com-q, false), (pq:pmes, inftab), (in-q, out-q) ) I- falls pmes E ProMes und next = false,

cP, ( (pmes, com-q, false), (pq, inftab) , (in-q, out-q) ) falls pmes E ProMes und next = true.


3. Bearbeitung von Verwaltungsnachrichten

( (red-q, com-q, next), (pq, inftab), (ames: in-q, out-q) ) I-cp, ( (red-q, com-q, next), (pq', inftab'),

Die F\lllktion

(in-q, out-q: mesl : ... : mesk))

falls ames E AdminM es und (mesl : ... : meSk, (pq', inftab')) :=

handle-admin-message (ames, (pq, inftab)) ,

handle-admin-message: AdminMes x LStcp ~ ({1, ... ,n} x Messages)* x LStcp

wird nicht weiter spezifiziert.

Damit haben wir die prinzipielle Organisation der Nachrichtenbearbeitung des Kommunikationsprozessors vollstandig beschrieben. Das Transitionssystem des Kommunikationsprozessors ist nichtdeterministisch, da wir keinerlei Vorgaben tiber die Reihenfolge der Bearbeitung von Nachrichten der Reduktionseinheit oder anderer Prozessorelemente gemacht haben. Wir fahren nun fort mit der Spezifikation des zweiten Prozessors in der Kommunikationseinheit.

11.4 Spezifikation des N etzwerkadapters

Der Netzwerkadapter ist das Bindeglied zwischen dem Netzwerk und dem Kommunikationsprozessor. Auf dem hier betrachteten Abstraktionslevel hat er keinen 10-kalen Speicher, sondern lediglich Zugriff auf die Nachrichtenwarteschlangen im mit den Kommunikationsprozessor geteilten Speicher sowie auf die N etzanschlufistellen, die wir als "In-" bzw. "Outports" bezeichnen.

Da wir von der speziellen Struktur des Verbindungsnetzwerkes abstrahieren, hat jedes Prozessorelement zu jedem anderen Prozessorelement eine direkte Kopplung, d.h. jedes Prozessorelement hat n -1 'Inports' und n -1 'Outports', wobei, wie wir spater sehen werden, das i-te 'Inport' von Prozessorelement j =f=. i mit dem j-ten 'Outport' von Prozessorelement i gekoppelt ist (1 $ i =f=. j $ n).

Wir bezeichnen verbundene Ports in den Spezifikationen mit denselben Namen, und behandeln sie auf dem hier betrachteten Abstraktionslevel wie gemeinsame Speicherzellen. Das i-te 'Inport' von Prozessor j wird mit portij , das i-te 'Outport' von Prozessor j mit portji bezeichnet.

Die Aufgabe des Netzwerkadapters ist einerseits das Einsammeln von Nachrichten von den 'Inports' und andererseits das Verteilen der Nachrichten aus der

11.4. SPEZIFIKATION DES NETZWERKADAPTERS 331

Ausgabewarteschlange in die entsprechenden 'Outports'. Die von den 'Inports' gelesenen Nachrichten werden ohne die vorangestellte Prozessornummer in die Eingabewarteschlange geschrieben. Wiederum machen wir keine Annahmen uber die Reihenfolge, in der Nachrichten von den 'Inports' bzw. von der Ausgabewarteschlange bearbeitet werden. Wir erhalten also folgendes nichtdeterministische Transitionssystem als Spezifikation des Netzwerkadapters.

11.4.1 Definition 1. SeijE{l, ... ,n}.

Der j-te Netzwerkadapter NAj wird als Transitionssystem

NAj:= (SMIO x Xi=l,ii-jPortij x Xi=l,ii-jPortji,f-NA,,INNA,) , ., , .., 'V" 'V'

'Inports' 'Outports'

mit der Zustandsmenge

wobei fur i E {I, ... , n} \ {j} : Portij := Portji := Netmes U {nil},

der Ubergangsrelation

und der Anfangszustandsmenge

2. Die Ubergangsrelation f-NAJ wird dabei wie folgt festgelegt:

Ein Zustand des j-ten Netzwerkadapter hat folgende allgemeine Form:

( (in-q, out-q), port1j , ... ,portnj , portjl' ... ,portjn )

mit (in-q, out-q) E SMlO, portij E Portij, portji E Portji(l ~ i ~ n, i =/:. j).

Wir unterscheiden folgende FaIle:

(a) Einlesen einer Nachricht von 'Inport' portij (1 ~ i ~ n, i =/:. j): ( (in-q, out-q), port1j , ... , [j, mes] , ... , portnj , portjll ... , portjn)

~

portij f-NA, ( (in-q:mes, out-q),

port1j , ... , ~ , ... , portnj , portj1 , ... , portjn)

Port·· lJ


(b) Laden eines 'Outports' portjj: mit i E {I, ... , n} \ {j}) { (in-q, [i,mes]:out-q),

portlj , ... ,portnj,portjl , .. ·, ~, ... ,portjn)

I-NAJ { (in-q, out-q), Port ..

J'

portlj, ... , portnj , portjll ... , [i, mes]' ... , portjn) ~

portji

3. Die AnJangszustandsmenge IN NAJ des j-ten Netzwerkadapters ist einelementig:

1NNAJ:= {{(€,€),?il,.~.,ni9}·

2(n-l)-mal

Damit sind aIle in der parallelen Maschine enthaltenen Prozessoreinheiten formal spezifiziert. 1m folgenden Abschnitt zeigen wir, wie die verschiedenen Prozessoreinheiten zusammenarbeiten. Wir werden zunachst aus den Transitionssystemen von Netzwerkadapter und Kommunikationsprozessor das Transitionssystem der Kommunikationseinheit definieren. Aus den Transitionssystemen von Kommunikations- und Reduktionseinheiten erzeugen wir dann Transitionssysteme zur Spezifikation der Prozessorelemente. Durch Kombination dieser erhalten wir schlieBlich ein nichtdeterministisches Transitionssystem fur die gesamte parallele abstrakte Maschine.

11.5 Komposition der Prozessoreinheiten

Zur Komposition von autonom arbeitenden Prozessoreinheiten, die durch Transitionssysteme gegeben sind, definieren wir zunachst einen aIlgemeinen Operator.

11.5.1 Definition Seien Ti = (LSti x SSt, I- j , INj) (i E {1,2} Transitionssysterne, deren Zustandsmenge jeweils in einen lokalen Teil LStj (Local Store) und einen gemeinsamen Teil SSt (Shared Store) zerfaIlt.

Sei combine : SSt x SSt X SSt - -+ SSt eine Funktion, die zu einem Zustand des gemeinsamen Teils und zwei Folgezustanden, falls moglich, einen kombinierten Folgezustand bestimmt.

Dann heif3t

Tl II(SSt,combine) T2 := (LSt l x SSt x LSt2,1-,IN)

11.5. KOMPOSITION DER PROZESSOREINHEITEN 333

die parallele Komposition von T1 und T2 mit Synchronisation auf SSt mittels combine, wobei

wie folgt definiert ist:

(lstt. sst, lst2) I- (lst~, sst', lst~)

gilt, falls

1. (lstt. sst) 1-1 (lst~, sst') und lst2 = lst~ oder 2. (lst2, sst) 1-2 (lst~, sst') und lst1 = lst~ oder 3. (lst1,sst) h (lst~,sstd und (lst2,sst) I- (lst~,sst2)

und sst' = combine(sst,sst1,sst2) E SSt,

und IN:= ((lst1,sst,lst2) I (lst1,sst) E IN1,(lst2,sst) E IN2} ist.

Diese allgemeine Definition der parallelen Komposition von Transitionssystemen ermoglicht uns nun die Spezifikation der Kommunikationseinheiten, der Prozessorelemente und schlieBlich nach Verallgemeinerung des Operators fur mehr als zwei Operanden der gesamten parallelen abstrakten Maschine.

Die Kommunikationseinheit eines Prozessorelementes besteht aus den autonom arbeitenden Einheiten des Netzwerkadapters und des Kommunikationsprozessors, die einen gemeinsamen Speicherbereich mit zwei Nachrichtenwarteschlangen teilen. Der Zugriff auf diese Warteschlangen ist so geregelt, daB jeder Prozessor von einer der beiden Warteschlangen das erste Element lesen und loschen kann und/oder an das Ende der anderen Warteschlange eine oder mehrere Nachrichten schreiben kann. Auf diese Weise konnen keine Konflikte beim Zugriff auf den gemeinsamen Speicher auftreten. Die combine-Funktion wird so definiert, daB als gemeinsamer Folgezustand der Zustand gewahlt wird, bei dem die Zustandsveranderungen, die von den beiden Einzelprozessoren vorgenommen wurden, beide berucksichtigt werden.

11.5.2 Definition Die j-te Kommunikationseinheit (1 ~ j ~ n) wird als Transitionssystem mittels paralleler Komposition der Transitionssysteme des j-ten Kommunikationsprozessors und des j-ten Netzwerkadapters definiert:

wobei combineIO : SMro -4 SMIO fur (in-qi,out-qi) E SMIO(l ~ i ~ 3) wie folgt definiert wird:


combineIO ((in-ql, out-ql)' (in-q2' out-q2)' (in-q3' out-~)) (in-q2 . (in-q3 \ in-ql)' out-~ . (out-q2 \ out-ql))'

falls in-ql Prafix von in-~ und in-q2 Suffix von in-ql sowie out-ql Prafix von out-q2 und out-~ Suffix von out-ql'

nicht def. sonst.

Dabei bezeichne . die Konkatenation und \ die Differenz von Worten.

In analoger Weise erhalten wir die formale Spezifikation der Prozessorelemente durch parallele Komposition der Transitionssysteme von Reduktionseinheit und Kommunikationseinheit.

11.5.3 Definition Das j-te Prozessorelement (1 ~ j < n) wird wie folgt als Transitionssystem spezifiziert:

wobei combinepE : SM3 - SM fUr (red-qi, com-qi' nexti) E SM(l ~ i ~ 3) wie folgt festgelegt wird:

combinepE((red-ql' com-ql' next1), (red-q2' com-~, next2), (red-q3' com-q3' next3))

(red-q2' (red-~ \ red-ql),com-~· (com-q2 \ com-ql) , next), falls red-ql Prafix von red-~ und red-q2 Suffix von red-ql, sowie com-ql Prafix von com-q2 und com-~ Suffix von com-q3

{true falls next2 = true

und next := und red-~ = €

false sonst, nicht def. sonst.

Das Prozeflanforderungsflag im gemeinsamen Speicher von Reduktions- und Kommunikationseinheit kann nach einem parallelen Zustandsiibergang nur den Wert true haben, wenn die Reduktionseinheit in den Wartemodus iibergeht, also das Flag setzt und die Kommunikationseinheit keine Nachricht an die Reduktionseinheit sendet, also das Flag nicht zuriicksetzt.


Bevor wir auf der Basis der Transitionssysteme fUr Prozessorelemente das Transitionssystem fur die parallele abstrakte Maschine definieren, erweitern wir zunachst den Paralleloperator fur Transitionssysteme fur k Argumente, von denen je zwei einen gemeinsamen Speicherbereich haben.

11.5.4 Definition Sei k ~ 2. Seien

mit (1 :::; i :::; k) k Transitionssysteme.

Fur i,j E {I, ... , k}, i < j teilen Ti und Tj den Zustandsraum SMij .

Seien fur i, j E {I, ... , k}, i > j

(k 2 - k) /2 Funktionen zur Kombination von Folgezustanden der gemeinsamen Zustandsraume.

Dann definieren wir die parallele Komposition von T1 bis Tk mit Synchronisation auf (SMij 11 :::; i < j :::; k) mittels (combineij 11 :::; i < j :::; k) :

durch

( ... ((T1 II(SM12,combine12) T2 ) II(SM13XSM23,(combine13,combine23») T3 )···

••. II(X~':-llsM'k,(combinelk, ... ,combinek_l,k») Tk)'

Dabei bezeichne (combine1j, ... , combinej_1,j) (1 :::; j :::; k) die Paarfunktion, fur die gilt:

( b' b') ( j-1 SM )3 j-1sM com me1j,"" com mej_l,j : Xi=1 ij --+ Xi=1 ij

mit

(combinelj, ... , combinej_l,j)

((smL,···, Sm3_I,j), (smij ,···, Sm;_I,j), (sm~j"'" smJ_I,j)) = (combinelj((smL, smij , smV)"'"

combinej-l,j(smJ_I,j, Sm;_1,j' smj_1,j))'


Mit dieser vorbereitenden Definition folgt unmittelbar die formale Spezifikation der parallelen abstrakten Maschine:

11.5.5 Definition 1. Die gemeinsamen Zustandsraume der verschiedenen Pro-zessorelemente bestehen aus den 'Ports', iiber die die Kommunikation erfolgt.

Wir definieren also

8M~E := Portij x Portji (1 ~ i < j ~ n).

tIber Portij erfolgt der Nachrichtentransfer von i nach j, iiber Portji in umgekehrter Richtung. Zur Kombination der Folgezustande benutzen wir die wie folgt definierten Funktionen

Fiir 1 ~ i < j ~ n, (portfj,portji) E 8Mij (1 ~ k ~ 3) ist combinef;E wie folgt definiert:

(port¥, portli) ist der durch PEi gegebene Folgezustand und (portij , portji) der durch PE j gegebene Folgezustand.

combine~E((port}j' port}i)' (portt, port]i), (port~j' port;i))

't ~t _ {port~l falls portll = port~l' IDl por kl - port~l falls portll = port~l' falls portll = port~l oder portll = port~l fiir k,l E {i,j},k =J 1

nicht definiert sonst

2. Die parallele abstrakte Maschine mit n Prozessorelementen wird somit definiert durch

PAM n :=IIn«SMfE combinePE)II<i<J"<n) (PEl, ... , PEn). I, ' '3 - -

Die Spezifikation der parallelen abstrakten Maschine ist sehr allgemein gehalten. In der Anfangszustandsmenge sind sogar verschiedene Anfangsbelegungen des Programmspeichers zugelassen. Zur Ausfiihrung von Kombinatorprogrammen nehmen wir allerdings an, daB jede Programmspeicherkomponente in den verschiedenen Prozessorelementen mit dem in Definition 1004.7 festgelegten Programmspeicher zum Kombinatorprogramm initialisiert ist. Die Berechnung startet


mit der Urtask, die der Ausfiihrung des Hauptprogramms entspricht, auf dem ersten Prozessorelement und endet auch dort, wenn die Urtask mit dem Ergebnis des Hauptprogramms iiberschrieben wurde.

Bevor wir unseren Maschinenentwurf zur parallelen Implementierung funktionaler Sprachen mit anderen in der Literatur beschriebenen Ansatzen vergleichen, mochten wir im folgenden Kapitel einen Uberblick iiber eine Simulation der abstrakten Maschine auf einem realen Multicomputersystem geben und auf einige Implementierungsaspekte naher eingehen.

[Informatik-Fachberichte] Parallele Implementierung funktionaler Programmiersprachen Volume 232 ||...

Documents

Transcript of [Informatik-Fachberichte] Parallele Implementierung funktionaler Programmiersprachen Volume 232 ||...