Realisierung eines blockbasierten Pipelining-Algorithmus

Ein solches elementweises Pipelining der Stufen- bzw. Argumentvektoren ist zwar möglich, in der Praxis hat sich jedoch gezeigt, daß eine blockweise Arbeitsweise Geschwindigkeitsvorteile bietet. Der blockweise Algorithmus ist darüber hinaus einfacher zu realisieren und zu beschreiben. Im folgenden soll deshalb eine blockweise Implementierung auf Basis der in Abschnitt2.4vorgestellten Implementierung (D) näher beschrieben werden.

Die resultierende Implementierung soll mit (PipeD) bezeichnet werden. Sie speichert wie Implemen-tierung (D) nur die Argumentvektoren w1, . . . ,ws (mit w1 = η_κ). Die Stufenvektorenv1, . . . ,vs werden dagegen nicht explizit gespeichert. Wir wählen eine Aufteilung der Argumentvektoren in Blöcke der Grö-ßeB, wobei wir eine BlockgrößeB≥d(f)wählen. Zur Vereinfachung der Beschreibung seinein Vielfaches von B, so daß sich eine Aufteilung der Argumentvektoren in nB = n/BBlöcke ergibt. Der im folgenden vorgestellte Algorithmus arbeitet jedoch auch in dem Fall korrekt, daß jeweils der letzte Block eines Vektors eine kleinere Größe besitzt. Die Wahl einer BlockgrößeB≥d(f)führt dazu, daß die Funktionsauswertung für einen BlockJ,fJ(t,w)mit

fJ(t,w) = (f_(J−1)B+1(t,w), . . . ,fJB(t,w)) ,

höchstens Komponenten der BlöckeJ−1,JundJ+1 des Argumentvektorswbenutzt. Für die Funktions-auswertung eines Blocks J angewendet auf den Argumentvektorws werden also höchstens die 3 Blöcke J−1,Jund J+1 vonwsbenötigt. Zur Berechnung dieser 3 Blöcke benutzen die zugehörigen Funktions-auswertungen höchstens Komponenten der 5 Blöcke J−2, J−1, J, J+1 und J+2 vonws−1. Setzt man dies bis zur Stufe 1 fort, werden höchstens die 2s+1 BlöckeJ−s, . . . ,J+sdes Argumentvektorsw1 benö-tigt. Diese Abhängigkeiten werden in Abb.4.1(a) verdeutlicht. Diese Abbildung veranschaulicht auch, daß nach der Durchführung der Funktionsauswertung für einen BlockJder Stufeszur Bestimmung der zuge-hörigen Blöcke von∆η unde und der vorausgehenden Bestimmung aller dazu notwendigen Argument-vektorblöcke der vorhergehenden Stufen nur noch ein weiterer Argumentvektorblock pro Stufe berechnet werden muß, um den nächsten Block von∆ηundemit IndexJ+1 bestimmen zu können.

Dies läßt sich ausnutzen, um folgenden Algorithmus zu realisieren, der in Abb.4.1(b) veranschaulicht wird. Abbildung4.2zeigt den Pseudocode des Berechnungskernels der resultierenden Implementierung.

4.2 Lokalitätsoptimierungen für sequentielle Implementierungen 175 1. Initialisierung der Pipeline:Argumentvektorw1ist bereits bekannt, da er identisch mit dem Approxi-mationsvektor des vorherigen Zeitschrittes,η_κ, ist. Es wird daher mit der Berechnung von Block 1 des Argumentvektorsw2 begonnen, wozu lediglich die Blöcke 1 und 2 von w₁ bekannt sein müssen. Ein Block einer höheren Stufe kann im Moment noch nicht berechnet werden. Deshalb fahren wir mit der Berechnung von Block 2 des Argumentvektorsw2fort, wofür auf die Blöcke 1, 2 und 3 vonw₁ zugegrif-fen werden muß. Jetzt können wir Block 1 vonw3berechnen, da hierzu nur die Blöcke 1 und 2 vonw2

benötigt werden. Als nächstes berechnen wir Block 3 vonw2, Block 2 vonw3und Block 1 vonw4, und fahren in gleicher Weise fort, bis Blocksvonw2und Block 2 vonws berechnet wurde. Jetzt kann der erste Block von∆ηundeberechnet werden. Danach ist die Initialisierung der Pipeline abgeschlossen.

2. Diagonaler Sweep über die Argumentvektoren:Nach der Initialisierung der Pipeline können wir block-weise über die Systemdimension iterieren, wobei in jedem Iterationsschritt J für J = s+1, . . . ,nB in einem diagonalen Lauf über die Argumentvektoren je ein neuer Argumentvektorblock vonw2, . . . ,ws

und ein Block der Vektoren∆ηundeberechnet wird.

3. Finalisierung der Pipeline:Nachdem durch den diagonalen Sweep die letzmögliche vollständige Dia-gonale berechnet wurde, wird die Pipeline – der bisherigen Vorgehensweise folgend – abgebaut.

4.2.2 Theoretische Analyse des Lokalitätsverhaltens

Die wesentlichen Elemente der Implementierung (PipeD), die das Lokalitätsverhalten bestimmen, sind zum einen die Makros STAGE1() und STAGE() zur Verarbeitung einzelner Blöcke, zum anderen der diagonale Lauf über die Stufen. Die beiden Makros besitzen eine Schleifenstruktur, die derjenigen der Schleifen über die Systemdimension und der darin eingeschlossenen Schleifen der Ausgangsimplementierung (D) ent-spricht (vgl. Abb.2.8). Der wichtigste Unterschied besteht darin, daß die Schleifen über die Systemdimen-sion innerhalb der Makros nicht über alle Systemkomponenten iterieren, sondern nur über dieB Kompo-nenten eines vorgegebenen Blocks. Dementsprechend sind die Arbeitsräume (Tab.4.1) durch Vielfache von Bgeprägt; aufgrund der Funktionsauswertungen aber auch durch die Zugriffsdistanz der Funktionf.

Die entscheidenden zwei Arbeitsmengen werden jedoch durch den diagonalen Lauf über die Stufen (einschließlich Initialisierung und Finalisierung der Pipeline) geprägt. Die erste entsteht durch die Menge aller während eines Zeitschrittes verwendeten Vektoren und ermöglicht die Wiederverwendung dieser Vek-toren innerhalb aufeinanderfolgender Zeitschritte. Wir gehen dazu an dieser Stelle davon aus, daß wie in Implementierung (D) alle Argumentvektoren vollständig gespeichert werden. Dann beträgt diese Arbeits-menge, wie im Fall der Implementierung (D),(s+3)n, was auch dem notwendigen Speicherplatzbedarf entspricht.

Die zweite wichtige Arbeitsmenge ist geprägt durch den Arbeitsraum RI des diagonalen Laufs über die Stufen, d. h. der Schleife in Zeile 31. Die Schleifen zur Initialisierung (Zeile 25) und zur Finalisierung (Zeile 37) der Pipeline sind dieser sehr ähnlich, allerdings entfallen einige Blöcke, die außerhalb der Vektor-grenzen liegen würden. Der ArbeitsraumRI des diagonalen Laufs über die Stufen ist deshalb von großer Bedeutung, weil er die Wiederverwendung von Daten zwischen aufeinanderfolgenden Iterationen der über die Systemdimension laufenden Schleife, den sogenannten „Pipelining-Schritten“, ermöglicht. Diese Schlei-fe ist die äußerste SchleiSchlei-fe des Berechnungskernels und wird sehr häufig wiederholt. Die in diesem Arbeits-raum enthaltenen Blöcke sind in Abb.4.1(c) veranschaulicht. Er besteht aus 3sBlöcken, auf die innerhalb von Funktionsauswertungen zugegriffen wird, insgesamt 2sBlöcken der Vektoren∆ηundesowie

zusätz-lich s

Argumentvektorblöcken, die unter Verwendung von Ergebnissen von Funktionsauswertungen aktualisiert werden. Hinzu kommt ein Block des Vektorss, in dem die in jedem Pipelining-Schritt berechneten Skalie-rungsfaktoren gespeichert werden. Insgesamt erhalten wir somit:

|RI|=

1: // Makro STAGE1: Auswertung des Blocks mit Index J des Argumentvektorsw1=η_κ

2: #define STAGE1(J)

3: {

4: for(j:= (J−1)B+1;j≤min{JB,n};j++)

5: {

6: v˜:=h fj(t+c1h,η);

7: s[_j]_:=|η[_j]|+|v˜|;

8: for(i:=_2;i≤s;i++)wi[j]_:=η[j] +a_i1v;˜

9: ∆η[j]:=b₁v;˜

10: e[j]:=b^˜₁v;˜

11: }

12: }

13: // Makro STAGE: Auswertung des Blocks mit Index J des Argumentvektorsw_l

14: #define STAGE(J,l)

15: {

16: for(j:= (J−1)B+1;j≤min{JB,n};j++)

17: {

18: v˜:=h fj(t+clh,wl);

19: for(i:=l+1;i≤s;i++)wi[j]+=ailv;˜

20: ∆η[j]₊₌b_lv;˜

21: e[j]_{+= ˜}b_lv;˜

22: }

23: }

24: // Initialisierung der Pipeline

25: for(J:=1;J≤s;J++)

26: {

27: STAGE1(J);

28: for(l:=2;l≤ J;l++) STAGE(J−l+1,l);

29: }

30: // Diagonaler Lauf über die Stufen

31: for(J:=s+_1;J≤n_B;J++)

32: {

33: STAGE1(J);

34: for(l:=2;l≤s;l++) STAGE(J−l+1,l);

35: }

36: // Finalisierung der Pipeline

37: for(J:=2;J≤s;J++)

38: for(l:=J;l≤s;l++) STAGE(nB+J−l,l);

Abb. 4.2:Sequentielle Variante der Implementierung (PipeD).

4.2 Lokalitätsoptimierungen für sequentielle Implementierungen 177

ZeileI|I|RIRL|RI||RL| 4j=(J−1)B+1,...,JBBw2[j],...,ws[j],∆η[j],e[j],s[j];BKomp.vonw2,...,ws,∆η,e,s;D+s+2(s+3)B+D−1 DKomp.vonηB+D−1Komp.vonη 7i=2,...,ss−1wi[j],η[j]w2[j],...,ws[j],η[j]2s 15j=(J−1)B+1,...,JBBwl+1[j],...,ws[j],∆η[j],e[j];BKomp.vonwl+1,...,ws,∆η,e;D+s−l+2(s−l+3)B+D−1 DKomp.vonwlB+D−1Komp.vonwl 18i=l+1,...,ss−lwi[j]wl+1[j],...,ws[j]1s−l Tab.4.1:ArbeitsräumederindersequentiellenVariantederImplementierung(PipeD)innerhalbderMakrosSTAGE1()undSTAGE()verwendetenSchleifen.

s |RI|/B s |RI|/B s |RI|/B

1 6 5 32 10 87

2 11 6 41 11 101

3 17 7 51 12 116

4 24 8 62 13 132

9 74

Tab. 4.2:Größe des ArbeitsraumesR_I des diagonalen Laufes über die Stufen nach (4.2) in Anzahl von Blöcken für verschiedene Stufenzahlens.

Tabelle4.2zeigt die resultierende Größe des Arbeitsraumes als Anzahl von Blöcken für verschiedene Stu-fenzahlen.

Der ArbeitsraumRIist also nur von der Stufenzahlsund der BlockgrößeBabhängig, jedoch nicht direkt von der Systemgrößen, wie dies für Implementierung (D) der Fall war. Die BlockgrößeBmuß jedoch min-destens so groß wie die Zugriffsdistanzd(f)gewählt werden, die abhängig von der Wahl der Problemgröße sein kann. Da wir annehmen, daß die Zugriffsdistanz beschränkt ist, alsod(f)n, führt der vorgeschlage-ne Algorithmus dennoch zu eivorgeschlage-ner erheblichen Reduktion des ArbeitsraumesRIder äußersten Schleife des Berechnungskernels. Für Implementierung (D), in der die äußerste Schleife über die Stufen iterierte, war die Größe dieses Arbeitsraumes ein Vielfaches vonn. Sie verringerte sich zwar in jeder Stufe umn, betrug aber in der letzten Stufe noch 3n.