15.10.2013 Aufrufe

zu diesem Thema und Infos zum Lehrstuhl

zu diesem Thema und Infos zum Lehrstuhl

zu diesem Thema und Infos zum Lehrstuhl

MEHR ANZEIGEN
WENIGER ANZEIGEN

Sie wollen auch ein ePaper? Erhöhen Sie die Reichweite Ihrer Titel.

YUMPU macht aus Druck-PDFs automatisch weboptimierte ePaper, die Google liebt.

Programmierung<br />

<strong>Lehrstuhl</strong> für<br />

Programmierung<br />

Einleitung<br />

Am <strong>Lehrstuhl</strong> für Programmierung befassen wir uns<br />

mit Modellen <strong>und</strong> Techniken <strong>zu</strong>r automatischen Verbesserung<br />

– <strong>und</strong> sogar Herstellung – von Programmen.<br />

Damit nehmen Sie den Programmierern ja ihre Arbeit<br />

weg!<br />

In gewissem Sinne schon. Aber seien Sie beruhigt.<br />

Es bleibt noch genug Arbeit für die Programmierer<br />

übrig. Mit unseren Techniken werden sie jedoch verlässlichere<br />

<strong>und</strong> leistungsfähigere Programme schneller<br />

erstellen können.<br />

Können Sie mir ein Beispiel geben?<br />

Schleifenparallelisierung<br />

Gern. Viele Programme verbringen in ihren Abläufen<br />

die meiste Zeit in Sätzen von verschachtelten Schleifen.<br />

Nehmen Sie als Beispiel das Produkt C zweier<br />

for i from 0 to n–1<br />

quadratischer Matrizen A <strong>und</strong> B mit Ausdehnung n.<br />

for j from 0 to n–1<br />

for k from 0 to n–1<br />

C[i,j] = C[i,j] + A[i,k]*B[k,j]<br />

Prof. Christian Lengauer, Ph.D<br />

Sekretariat:<br />

Eva Reichhart<br />

Wiss. Mitarbeiter:<br />

Dr.-Ing. Sven Apel<br />

Armin Größlinger<br />

Michael Claßen<br />

Ehem. Wiss. MitarbeiterInnen:<br />

(Auswahl)<br />

Dr. Nils Ellmenreich<br />

Dr. Peter Faber<br />

Prof. Dr. Sergei Gorlatch<br />

PD Dr. Martin Griebl<br />

Prof. Dr. Ulrike Lechner<br />

Es wird durch den folgenden Schleifensatz berechnet:<br />

for i from 0 to n–1<br />

for j from 0 to n–1<br />

for k from 0 to n–1<br />

C[i,j] = C[i,j] + A[i,k]*B[k,j]<br />

In wissenschaftlichen Anwendungen sind heut<strong>zu</strong>tage<br />

die Datensätze so groß, dass eine sequenzielle<br />

Ausführung von einem Schleifenschritt nach dem<br />

anderen oft <strong>zu</strong> lange dauert. Immerhin werden n 3<br />

Schritte benötigt.<br />

Ist es nicht am einfachsten, einen Rechner mit einem<br />

schnelleren Prozessor <strong>zu</strong> kaufen? Die gibt es doch<br />

alle paar Jahre.<br />

Das wird in der Zukunft immer weniger möglich<br />

sein. Wir sind mittlerweile bei Forderungen nach Re-<br />

chengeschwindigkeiten angelangt, die ein einzelner<br />

Prozessor nicht mehr erreichen kann.<br />

Ah, darum enthalten die neuen Rechner seit kurzem<br />

wohl zwei oder vier Prozessoren...<br />

Das ist einer der Gründe. Wir müssen das Programm<br />

also so umschreiben, dass es sich auf mehrere Prozessoren<br />

bezieht.<br />

Na, dann machen wir doch einfach einige Schleifenschritte<br />

parallel!<br />

Ja, aber welche? Es gibt viele Möglichkeiten. Wir<br />

wollen, dass unsere Berechnung so schnell wie möglich<br />

ist, <strong>und</strong> haben unter dieser Vorausset<strong>zu</strong>ng vielleicht<br />

noch andere Wünsche, etwa eine minimale<br />

Anzahl von Prozessoren <strong>zu</strong> benutzen oder einen<br />

maximalen Durchsatz <strong>zu</strong> erreichen (wenn wir viele<br />

Matrixprodukte hintereinander berechnen wollen).<br />

Da müssen wir wohl scharf hinsehen, um die beste<br />

Lösung für unsere Wünsche <strong>zu</strong> fi nden, <strong>und</strong> beim<br />

Umkodieren höllisch aufpassen, dass sich kein Fehler<br />

einschleicht <strong>und</strong> dass uns das parallele Programm<br />

dasselbe Ergebnis liefert wie das sequenzielle.<br />

Nein, das müssen wir nicht. Wir brauchen das sequenzielle<br />

Programm nur einem Programm, einem<br />

sogenannten Schleifenparallelisierer, <strong>zu</strong> übergeben<br />

<strong>und</strong> ihm mit<strong>zu</strong>teilen, an welchen Optimierungen uns<br />

am meisten gelegen ist. Er generiert uns das beste<br />

parallele Programm da<strong>zu</strong> <strong>und</strong> garantiert, dass es<br />

dem sequenziellen Programm entspricht.<br />

Das ist ja ein Ding! Wie geht denn das?<br />

Wir arbeiten mit einem mathematischen Modell. Im<br />

Fall des Matrixproduktes ist es ein Kubus, der an je-<br />

Schleifenschritte mit Abhängigkeiten<br />

dem Punkt einen Schleifenschritt enthält. Pfeile zwischen<br />

den Punkten deuten an, welche Schritte vor<br />

welchen ausgeführt werden müssen. Dann schneiden<br />

wir den Kubus in Richtung der Pfeile in Scheiben.<br />

Alle Punkte auf einer Scheibe können parallel<br />

in einem Schritt ausgeführt werden.<br />

Und das geht automatisch?<br />

Ja. Wenn die Schleifensätze nicht gar <strong>zu</strong> wild programmiert<br />

sind, kann eine Analyse die Pfeile automatisch<br />

fi nden, <strong>und</strong> eine Optimierung den besten<br />

Schnitt. Der gibt uns in <strong>diesem</strong> Fall 2n+1 anstatt n 3<br />

Schritte, also einen proportionalen statt kubischen<br />

Zeitaufwand.<br />

Nun gut. Jetzt wissen wir für jeden Schleifenschritt,<br />

<strong>zu</strong> welcher Zeit er ausgeführt werden muss. Aber<br />

wie sieht es mit dem Prozessor aus, der ihn ausführen<br />

soll?<br />

Da haben wir wieder die Wahl. Diesmal liegt es an<br />

unseren weiteren Wünschen, wie wir uns entscheiden.<br />

Wenn wir Prozessoren sparen wollen, müssen<br />

wir die Schleifenschritte (d. h. Punkte) in den verschiedenen<br />

Scheiben so auffädeln, dass es möglichst<br />

j<br />

k<br />

i<br />

51


wenige „Fäden“ gibt; jeder Faden entspricht der Tätigkeit<br />

eines Prozessors. Wenn wir den Durchsatz<br />

maximieren wollen, brauchen wir mehr Prozessoren,<br />

also mehr Fäden. Da die Punkte auf jedem<br />

Faden aber weiter voneinander entfernt sind, kann<br />

der Prozessor versetzt zwei weitere Matrixprodukte<br />

berechnen, ohne dass wir bei der Berechnung jedes<br />

einzelnen Matrixprodukts Zeit verlieren.<br />

Sehr beeindruckend. Aber die Welt besteht nicht nur<br />

aus Matrixprodukten.<br />

Dies ist ja nur ein einfaches Beispiel für die Anwendung<br />

des sogenannten Polyedermodells. Wir können<br />

auch wesentlich kompliziertere Schleifenprogramme<br />

automatisch parallelisieren. Ebenso kann<br />

man das Modell da<strong>zu</strong> benutzen, auf einfache Weise<br />

die Granularität der Parallelität <strong>zu</strong> vergröbern, d. h.<br />

die Anzahl der von den Raumschleifen aufgezählten<br />

Prozessoren der der tatsächlich vorhandenen Prozessoren<br />

an<strong>zu</strong>gleichen.<br />

Dieses Modell scheint ja gerade <strong>zu</strong>r rechten Zeit für<br />

die neuen Mehrprozessorrechner <strong>zu</strong> kommen. Derartige<br />

Methoden könnten die Entwickler von Software<br />

für solche Rechner sehr entlasten.<br />

Genauso sehen wir es auch.<br />

Zeitaufteilung<br />

Raumaufteilung<br />

(niedrige Prozessorenzahl)<br />

Raumaufteilung<br />

(hoher Durchsatz)<br />

Feature-Orientierte<br />

Software-Entwicklung<br />

Es gibt aber noch andere Stellen, an denen wir<br />

glauben, den Programmierer mit automatischen<br />

Techniken unterstützen <strong>zu</strong> können. Betrachten wir<br />

einmal nicht wissenschaftliche, sondern Anwendungssoftware.<br />

Jeder, der schon mal an einem<br />

Computer gearbeitet hat, hat Anwendungssoftware<br />

verwendet. Beispiele sind Software <strong>zu</strong>m Schreiben<br />

<strong>und</strong> Gestalten von Textdokumenten oder Webbrowser<br />

<strong>und</strong> Email-Programme.<br />

Ja, solche Programme habe ich schon benutzt. Aber<br />

wo liegt das Problem?<br />

Das Problem ist, dass Anwendungssoftwaresysteme<br />

heut<strong>zu</strong>tage über eine riesige Menge an Funktionalität<br />

verfügen, die nur selten von einem Anwender<br />

auch verwendet werden kann. Ich wette mit Ihnen,<br />

dass die meisten Nutzer nicht mehr als 10 % der<br />

Funktionalität von Word ausnutzen.<br />

Und wenn schon... Wenn die Software mehr kann,<br />

als ich brauche, umso besser!<br />

Das Problem ist einerseits, dass Sie natürlich den<br />

kompletten Funktionsumfang bezahlen müssen.<br />

Andererseits wird die Software unnötig komplex,<br />

langsam <strong>und</strong> fehleranfällig. Oftmals ist es für Entwickler<br />

wie Anwender schwer, das Softwaresystem<br />

überhaupt noch <strong>zu</strong> überblicken, geschweige denn im<br />

Detail <strong>zu</strong> verstehen.<br />

Firmen sollten also Anwendungssoftware ausliefern,<br />

die genau das kann, was der individuelle<br />

K<strong>und</strong>e wünscht, <strong>und</strong> ihm auch nur das in Rechnung<br />

stellen?<br />

Genau. In <strong>diesem</strong> Zusammenhang sprechen wir<br />

auch von Features. Ein Feature ist ein Verhalten bzw.<br />

ein Stück Funktionalität, das sich der Anwender von<br />

einem Softwaresystem erhofft. Features in Textverarbeitungssoftware<br />

sind z. B. die Rechtschreibprüfung,<br />

die Möglichkeit <strong>zu</strong> drucken oder die Unterstüt<strong>zu</strong>ng<br />

verschiedener Sprachen.<br />

Und wie helfen Features nun, Anwendungssoftware<br />

besser <strong>zu</strong> bauen?<br />

Die Idee ist, dass die einzelnen Bestandteile, aus denen<br />

ein Softwaresystem besteht, den einzelnen Features<br />

des Softwaresystems <strong>zu</strong>geordnet werden. Wenn man<br />

so will, beantwortet man die Frage, welches Feature<br />

durch welche Teile des Softwaresystems umgesetzt<br />

wird. Oftmals ist diese Antwort aber recht kompliziert.<br />

Würde man die Teile eines Softwaresystems<br />

einfärben, die <strong>zu</strong> den jeweiligen Features gehören,<br />

so wären die farblichen Fragmente weit verstreut <strong>und</strong><br />

stark miteinander vermischt.<br />

Feature-Zugehörigkeiten in<br />

einem Codestück<br />

Also wenn man eine Zuordnung hat, kann man die<br />

Teile eines Softwaresystems weglassen, die von mir<br />

nicht bezahlt werden?<br />

Korrekt. Neben der Maßschneiderung von Softwaresystemen<br />

durch Features hat man aber noch<br />

weitere Vorteile. Der Anwender kann leichter einen<br />

Überblick über seine Anwendungssoftware bekommen.<br />

Und der Entwickler kann, wenn ein Fehler auftritt,<br />

feststellen, welche Features betroffen sind, <strong>und</strong><br />

so die Fehlerquelle eingrenzen. Da<strong>zu</strong> sind natürlich<br />

Methoden <strong>und</strong> Werkzeuge nötig, die unter anderem<br />

auch an unserem <strong>Lehrstuhl</strong> entwickelt werden.<br />

Okay, aber wo bleiben denn da die automatischen<br />

Techniken?<br />

Wir arbeiten auch an einem Werkzeug, das bei Angabe<br />

einer Sequenz von Features automatisch ein<br />

Softwaresystem erstellt, das die entsprechenden<br />

Funktionalitäten hat, <strong>und</strong> das obendrein gerade<br />

für diese Kombination von Funktionalitäten optimiert<br />

ist. Bei Weiterentwicklung dieser Technologie<br />

könnte sich ein K<strong>und</strong>e seine Anwendungssoftware<br />

so <strong>zu</strong>sammenstellen wie heute etwa einen Neuwagen<br />

– <strong>und</strong> sie wird dann auch ebenso automatisch<br />

<strong>zu</strong>sammengesetzt. Eine Konsequenz wäre, dass das<br />

Produkt dann auch mit ähnlichen Garantien ausgeliefert<br />

werden kann.<br />

53

Hurra! Ihre Datei wurde hochgeladen und ist bereit für die Veröffentlichung.

Erfolgreich gespeichert!

Leider ist etwas schief gelaufen!