Datenflußanalyse

Datenflußanalyse
Christoph Dreyer
Projektgruppe Programmanalyse für Java
1

Datenflußanalyse
Datenflußanalyse wird in Compilern benutzt.
Sie liefert Informationen über das Programm.
Diese werden zur Optimierung genutzt.
Compiler
Optimierung
Analyse
Kontrollflußanalyse
Transformation
Datenflußanalyse
Datenflußanalyse ist nicht nur zur Optimierung nützlich.
Auch für andere Zwecke formuliert man Datenflußprobleme.
Sie können dann mit Standardverfahren gelöst werden.
2

Programmanalyse
Was wird berechnet?
f0 = 0;
f1 = 1;
if (m ≤ 1) {
return m;
}
else {
i = 2;
while (i ≤ m) {
f2 = f0 + f1;
f0 = f1;
f1 = f2;
i++;
}
return f2;
}
Wie wird f2 berechnet?
Welche Werte kann f0 haben?
Wo wird f0 berechnet?
3

Ziele
• Datenflußprobleme kennen
• Datenflußgleichungen aufstellen können
• Lösungsverfahren verstehen
4

Überblick
1. ein Datenflußproblem
2. Datenflußgleichungen
3. ein Lösungsverfahren
4. andere Probleme
5. Verbesserungen des Algorithmus
6. ein anderes Verfahren
5

Erreichende Definitionen
Welche Definitionen erreichen eine bestimmte Verwendung?
Definition einer Variablen Der Variablen wird ein Wert
zugewiesen
Zerstören einer Definition Eine spätere Definition weist
derselben Variable einen Wert zu
Definition erreicht Verwendung Zwischen Definition
und Verwendung wird die Definition nicht zerstört
x = 0;
x = 1;
y = x + 1;
6

Programmablauf
Die Menge der erreichenden Definitionen ist unabhängig
vom Programmablauf.
x = 0;
if (a = 0) {
x = 1;
}
y = x + 1;
Eine Definition erreicht alle möglichen Verwendungen.
→ Ergebnismenge nicht exakt, sondern zu groß.
→ Suche nach kleinster Menge
7

Kontrollflußanalyse
Die Kontrollflußanalyse liefert einen Ablaufgraph auf dem
die Datenflußanalyse durchgeführt wird.
Kontrollflußanalyse
Ablaufgraph
Datenflußanalyse
B2
Y
entry
B1
B5
exit
N
N
B3
B4
Y
B6
8

Definitionen
Jeder Definition wird eine Nummer zugeordnet.
Block Variable Nummer
B1 m 1
B1 f0 2
B1 f1 3
B3 i 4
B6 f2 5
B6 f0 6
B6 f1 7
B6 i 8
GEN[b] Menge der erzeugten Definitionen
KILL[b] Menge der zerstörten Definitionen
Ein Block zerstört die durch ihn erzeugten Definitionen.
9

Datenflußgleichungen
Wenn der erste Befehl eines Grundblocks ausgeführt wird,
dann auch alle anderen.
in[b] Definitionen, die den Block erreichen
out[b] Definitionen, die den Block verlassen
By
Y
Bx
N
Bz
Eine Definition erreicht einen Block, wenn sie einen der
Vorgängerblöcke verlassen hat.
in[b] = ∪ p∈P RED[b] out[p]
Eine Definition verläßt einen Block, wenn sie entweder in
ihm erzeugt wurde oder ihn erreicht hat und nicht zerstört
wurde.
out[b] = GEN[b] ∪ (in[b] \ KILL[b])
10

iterativer Algorithmus
for all (b ∈ BLOCK) {
out[b] = GEN[b];
}
do {
change = false;
for all (b ∈ BLOCK) {
in[b] = ∪ p∈P RED[b] out[p];
oldout = out[b];
out[b] = GEN[b] ∪ (in[b] \ KILL[b]);
if (out[b] = oldout) {
change = true;
}
}
}
while (change == true);
11

Beispiel
Die Blöcke B4 und B6 bilden zusammen eine Schleife.
B4
B6
Der Block B6 enthält die Befehle des Schleifenrumpfs.
f2 = f0 + f1;
f0 = f1;
f1 = f2;
i++;
GEN[B6]= {5, 6, 7, 8}
KILL[B6]= {2, 3, 4, 5, 6, 7, 8}
in1[B6] = out1[B4] = ∅
out1[B6] = {5, 6, 7, 8}
in2[B6] = out2[B4] = {1, 2, 3, 4, 5, 6, 7, 8}
out2[B6] = {1, 5, 6, 7, 8}
12

Upwards Exposed Uses
Welche Verwendungen erreichen eine bestimmte Definition?
x = 0
x = 1
y = x + 1 z = x + 1
Verwendungen bewegen sich von unten nach oben.
Es handelt sich um ein Rückwärtsproblem.
out[b] = ∪ s∈SUCC[b] in[s]
in[b] = GEN ′ [b] ∪ (out[b] \ KILL ′ [b])
13

Verfügbare Ausdrücke
Welche Ausdrücke sind an einem Punkt verfügbar?
x = a + b
z = a + b
y = a + b
Der verfügbare Ausdruck muß auf jedem Pfad berechnet
werden.
Es handelt sich um ein Allproblem.
in[b] = ∩ p∈P RED[b] out[p]
Problem Konfluenzoperator gesuchte Lösung
Existenzproblem ∪ minimale Lösung
Allproblem ∩ maximale Lösung
14

Mengen
Mengen werden mit Bitvektoren implementiert.
Block Variable Nummer
B1 m 1
B1 f0 2
B1 f1 3
B3 i 4
B6 f2 5
B6 f0 6
B6 f1 7
B6 i 8
Nummer der Definition entspricht Position im Bitvektor.
GEN[B6] = 〈0, 0, 0, 0, 1, 1, 1, 1〉
KILL[B6] = 〈0, 1, 1, 1, 1, 1, 1, 1〉
Datenflußgleichungen:
in[b] = ∨ p∈P RED[b] out[p]
out[b] = GEN[b] ∨ (in[b] ∧ ¬KILL[b])
15

Transferfunktion
Transferfunktion F b berechnet den Effekt eines Blocks.
out[b] = F b(in[b])
F b(x) = GEN ∨ (x ∧ ¬KILL)
Die Menge P RSV [b] (preserve) enthält die Definitionen,
die durch den Block nicht beeinflußt werden.
P RSV = ¬KILL
F b(x) = GEN ∨ (x ∧ P RSV )
P RSV [B6] = 〈1, 0, 0, 0, 0, 0, 0, 0〉
F B6(x) = 〈x1, 0, 0, 0, 1, 1, 1, 1〉
Datenflußgleichungen →
→ Transferfunktionen und Konfluenzoperator
16

Beschleunigung
Zur Lösung des Datenflußproblems reicht im Idealfall ein
Durchlauf durch den Ablaufgraph.
Bx
Y
Bw
Bz
N
By
Schleifenköpfe müssen mehrmals berechnet werden. Nach
jeder Änderung müssen auch alle abhängigen Blöcke neu
berechnet werden.
B4
B6
in[B4] = out[B3] ∪ out[B6]
in[B6] = out[B4]
Bei Schleifen, die hintereinander ausgeführt werden, addieren
sich die zusätzlichen Berechnungen.
17

Reihenfolge
In und zwischen Schleifen profitiert man von der richtigen
Reihenfolge.
Vorwärtsrichtung: Knoten vor allen Nachfolgern besuchen
Rückwärtsrichtung: Knoten vor allen Vorgängern besuchen
Bx
Y
Bw
Bz
N
By
Richtung Reihenfolge Beispiel
vorwärts topologisch Bw, By, Bx, Bz
rückwärts postorder Bz, Bx, By, Bw
18

Strukturbasierte Analyse
Anderes Verfahren zum Lösen von Datenflußgleichungen.
Verallgemeinerung der Intervallanalyse.
Gemeinsamkeiten mit iterativem Verfahren:
• Transferfunktionen
• Konfluenzoperator
• Initialisierungswerte
Kontrollflußanalyse liefert jetzt control tree.
Control tree enthält Grundblöcke und abstrakte Blöcke.
Abstrakte Blöcke fassen Grundblöcke zusammen.
19

Verfahren
Zunächst Berechnung der Transferfunktionen für die
Grundblöcke.
Lösung wird mit zwei Durchläufen durch den control tree
berechnet.
entrya
entry B1a
B1 B2 B3a
B3 B4a
B4 B6
exit
B5
Im ersten Durchlauf werden bottom-up die Transferfunktionen
der abstrakten Blöcke berechnet.
Im zweiten Durchlauf werden top-down für jeden Block
Datenflußgleichungen aufgestellt und gelöst.
20

lock-Konstrukt
Alle Blöcke werden der Reihe nach ausgeführt.
B3a
B3 B4a
Transferfunktion:
block
B5
F B3a = F B5 ◦ F B4a ◦ F B3
Datenflußgleichungen:
in[B3] = in[B3a]
in[B4a] = F B3(in[B3])
in[B5] = F B4a(in[B4a])
21

if-then-else-Konstrukt
Zuerst wird der Block ausgeführt, der die Bedingung auswertet,
danach einer der beiden anderen Blöcke.
B1a
B1 B2 B3a
Transferfunktion:
if-then-else
F B1a = (F B2 ◦ F B1) ∨ (F B3a ◦ F B1)
Datenflußgleichungen:
in[B1] = in[B1a]
in[B2] = F B1(in[B1])
in[B3a] = F B1(in[B1])
22

while-Konstrukt
Die Bedingung wird ausgewertet, danach die Schleife entweder
verlassen oder der Schleifenrumpf ausgeführt und
noch einmal die Bedingung ausgewertet.
B4a
B4 B6
Transferfunktion:
while
F B4a’ = (F B6 ◦ F B4) ∨ id
F B4a = F B4 ◦ F B4a’
Datenflußgleichungen:
in[B4] = F B4a’(in[B4a])
in[B6] = F B4a(in[B4])
23

improper region
Einteilung in Gruppen:
acyclic keine rückführenden Kante
cyclic mit Rückwärtskante
improper Schleife mit mehreren Eingängen
Ablaufgraph einer improper region:
By
Bx
Bz
Datenflußgleichungen sind rekursiv:
in[Bx] = in[Bxa]
in[By] = F Bx(in[Bx]) ∨F Bz(in[Bz])
in[Bz] = F Bx(in[Bx]) ∨F By(in[By])
24

Knotenaufspaltung
Gleichungen werden mit iterativem Verfahren gelöst.
By
Bx
Bz
Oder durch Knotenaufspaltung:
By
Bx
Bz
Bza
Neue Schleife hat nur einen Eingang.
25

Zusammenfassung
Datenflußanalyse liefert Informationen über Programm.
Ergebnisse gelten für alle Programmabläufe.
Klassifizierung nach . . .
• Flußrichtung (vorwärts oder rückwärts)
• Allproblem oder Existenzproblem (Konfluenzoperator)
Transferfunktion aufstellen, dann Lösung berechnen.
viele Verfahren, hier: iterativ und strukturbasiert.
Aspekt iterativ strukturbasiert
Geschwindigkeit schnell schneller
Implementierung einfach kompliziert
Transformationen neue Berechnung Änderung
26

Ausblick
Datenflußanalyse wird auch benutzt, . . .
• zur interprozeduralen Datenflußanalyse
• um Decknamen zu bestimmen
• um Typinformationen zu berechnen
• zur Verfifikation von Programmen
27