Abstract
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. 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.
Timeline
On 2017-10-16, I submitted my dissertation for review. The core thesis is: Resource-aware programming in high-level languages on MPSoCs is feasible with manageable effort and improves performance.
On 2018-04-26, I successfully defended my dissertation.
Since 2018-06-20, my dissertation is published electronically on KITopen.
On 2018-12-19, I also got a printed version:
The cover image is from Unsplash. I chose that image because "cliff" appears in the first paragraph of the introduction.
For decades we scaled our computer architectures according to a common formula, but this will end soon. It does not mean that our current technology will stop working, but on our path up the mountain of ever more powerful computing, there is a cliff. The following sections describe how long-term hardware trends lead to that cliff, what ideas there are to overcome it, why hardware alone cannot solve it, and my contributions to a solution.