Resource-aware Programming in a High-level Language - Improved performance with manageable effort on clustered MPSoCs

Bis 2001 bedeutete Moores und Dennards Gesetz eine Verdoppelung der Ausführungszeit alle 18 Monate durch verbesserte CPUs.
Heute ist Nebenläufigkeit das dominante Mittel zur Beschleunigung von Supercomputern bis zu mobilen Geräten.
Allerdings behindern neuere Phänomene wie "Dark Silicon" zunehmend eine weitere Beschleunigung durch Hardware.
Um weitere Beschleunigung zu erreichen muss sich auch die Soft­ware mehr ihrer Hardware Resourcen gewahr werden.
Verbunden mit diesem Phänomen ist eine immer heterogenere Hardware.
Supercomputer integrieren Beschleuniger wie GPUs.
... mehr
Mobile SoCs (bspw. Smartphones) integrieren immer mehr Fähigkeiten.
Spezialhardware auszunutzen ist eine bekannte Methode, um den Energieverbrauch zu senken, was ein weiterer wichtiger Aspekt ist, welcher mit der reinen Geschwindigkeit abgewogen werde muss.
Zum Beispiel werden Supercomputer auch nach "Performance pro Watt" bewertet.
Zur Zeit sind systemnahe low-level Programmierer es gewohnt über Hardware nachzudenken, während der gemeine high-level Programmierer es vorzieht von der Plattform möglichst zu abstrahieren (bspw. Cloud).
"High-level" bedeutet nicht, dass Hardware irrelevant ist, sondern dass sie abstrahiert werden kann.
Falls Sie eine Java-Anwendung für Android entwickeln, kann der Akku ein wichtiger Aspekt sein.
Irgendwann müssen aber auch Hochsprachen resourcengewahr werden, um Geschwindigkeit oder Energieverbrauch zu verbessern.

Innerhalb des Transregio "Invasive Computing" habe ich an diesen Problemen gearbeitet.
In meiner Dissertation stelle ich ein Framework vor, mit dem man Hochsprachenanwendungen resourcengewahr machen kann, um so die Leistung zu verbessern.
Das könnte beispielsweise erhöhte Effizienz oder schnellerer Ausführung für das System als Ganzes bringen.

Ein Kerngedanke dabei ist, dass Anwendungen sich nicht selbst optimieren.
Stattdessen geben sie alle Informationen an das Betriebssystem.
Das Betriebssystem hat eine globale Sicht und trifft Entscheidungen über die Resourcen.
Diesen Prozess nennen wir "Invasion".
Die Aufgabe der Anwendung ist es, sich an diese Entscheidungen anzupassen, aber nicht selbst welche zu fällen.
Die Herausforderung besteht darin eine Sprache zu definieren, mit der Anwendungen Resourcenbedingungen und Leistungsinformationen kommunizieren.
So eine Sprache muss ausdrucksstark genug für komplexe Informationen, erweiterbar für neue Resourcentypen, und angenehm für den Programmierer sein.

Die zentralen Beiträge dieser Dissertation sind:

Ein theoretisches Modell der Resourcen-Verwaltung, um die Essenz des resourcengewahren Frameworks zu beschreiben,
die Korrektheit der Entscheidungen des Betriebssystems bezüglich der Bedingungen einer Anwendung zu begründen
und zum Beweis meiner Thesen von Effizienz und Beschleunigung in der Theorie.

Ein Framework und eine Übersetzungspfad resourcengewahrer Programmierung für die Hochsprache X10.
Zur Bewertung des Ansatzes haben wir Anwendungen aus dem High Performance Computing implementiert.
Eine Beschleunigung von 5x konnte gemessen werden.

Ein Speicherkonsistenzmodell für die X10 Programmiersprache, da dies ein notwendiger Schritt zu einer formalen Semantik ist, die das theoretische Modell und die konkrete Implementierung verknüpft.

Zusammengefasst zeige ich, dass resourcengewahre Programmierung in Hoch\-sprachen auf zukünftigen Architekturen mit vielen Kernen mit vertretbarem Aufwand machbar ist und die Leistung verbessert.

Until 2001 Moore's Law and Dennard Scaling implied that execution speed doubled every 18 months due
to better CPUs.
Today, concurrency is the dominant way for speedups from supercomputers to mobiles.
However, more recent phenomenons like Dark Silicon increasingly complicate speedups from hardware.
To realize further performance gains, software has to become more aware of the hardware resources.
A related phenomenon is increasingly heterogeneous hardware.
Supercomputers integrate accelerators like GPUs.
Mobile SoCs (for example in smartphones) integrate more and more features.
... mehr
Exploiting special hardware is a well-known technique to lower energy consumption,
which is another important aspect that must be balanced with raw performance.
For example, supercomputers are also rated by "performance per watt".
Currently, low-level programmers are used to think about hardware,
while the mainstream high-level programmers prefer to abstract
as much of the platform as possible (for example clouds).
High-level does not imply that hardware is irrelevant, just that it can be abstracted.
If you write a Java application for Android, battery use might be an important aspect.
Eventually, even high-level programming languages are pressured
to become resource-aware to improve speed or energy consumption.

Within the transregional collaborative research center "Invasive Computing",
I worked on these problems.
In my dissertation, I propose a framework to make high-level applications
resource-aware and thus improve performance,
which for example might result in improved efficiency or speedups for the system as a whole.

One core idea is that applications do not optimize on their own.
Instead, they give information to the operating system.
The operating system with its global view makes resource decisions.
This process we call "invasion" of resources.
The job of the application is to adapt to the operating system's decision, not to make its own.
The challenge is to define the language,
which applications use to communicate resource constraints and performance hints.
Such a language must be expressive enough for complex information,
extensible for future resource types, and convenient for the programmer.

The major contributions in this dissertation are:

A theoretic model of resource allocation to precisely describe
the essence of the resource-aware framework,
to reason about the correctness of the operating system decisions with respect to the constraints of an application,
and to proof my claims of efficiency and speedup in theory.

A framework and compilation path for resource-aware programming
implemented for the high-level programming language X10.
We implemented applications from High Performance Computing to evaluate this approach.
Speedups of 5x can be demonstrated.

A consistency model for the X10 programming language
as a necessary step for a formal semantics,
which bridges the theoretic model to the concrete implementation.


In one sentence: Resource-aware programming in high-level languages on
MPSoCs is feasible with manageable effort and improves performance.