Meta-level Engineering and Tooling for Complex Concurrent Systems

During the last decade, multicore processors have become commonplace in phones, tablets, laptops, and servers. As a result, software developers use concurrent programming techniques to utilize these processors. Especially in complex software systems, we see a wide range of these techniques being used, for instance to perform computations in parallel. This is problematic, because in contrast to classic programming techniques, concurrent programming has a pervasive influence on the whole system rather than being nicely confined to isolated parts. This makes concurrent systems hard to understand and debug. Unfortunately, todays debugging tools for concurrent programs work on the lowest abstraction level, e.g., on memory accesses instead of the high-level concurrency concepts that developers used to build the systems, which makes it even harder to understand the software. To support the development of such complex systems, we propose to investigate how to abstract from the wide range of concurrent programming techniques. The goal is to devise a common mechanism to build tools that are able to represent the high-level concurrency concepts to the developers so that they can better understand the software they build. Furthermore, we need to investigate how to implement such a common mechanism, because existing techniques affect the way programs behave and can hide the concurrency bugs a software developer might try to understand. So far, the question of how to build tools for the wide range of concurrent programming techniques has not been investigated. While others have focused on specific techniques, for the complex software systems we see today, this is not enough. To approach this problem, we propose to combine the unique expertises of the Software Languages Lab at the Vrije Universiteit Brussel, Belgium and the Institute for System Software of the Johannes Kepler University Linz, Austria. We will investigate how to design a common meta-level interface for tools from the high-level perspective of concurrent programming techniques, as well as the low-level perspective of the fundamental performance issues for its implementation to minimize interference with program execution. For our research, we will rely on Truffle, a novel language implementation framework that allows us to build prototypes and experiments with state-of-the-art performance while using the existing infrastructure of Java virtual machines. Based on this technical foundation, we will investigate in an iterative approach support for message-passing, shared-state, and declarative concurrency to devise a meta-level interface that abstracts from the specific concurrency models. Furthermore, we will investigate how to efficiently support time- travelling debugging in such a setting to provide tools and thereby developers with the information on high-level concurrency concepts of their software system and the ability to examine and understand how a bug occurred.

Moore's law, according to which the performance of processors doubles every 1.5 years, has reached its limit. As a result, our computers and smartphones increasingly have 4, 8 or 16 processors instead of just one. To make use of these processors, programs are parallelised so that parts of them run concurrently on different processors. However, parallelisation brings new problems. The interaction between parallel processes is inherently non-deterministic. Errors often occur sporadically and are usually difficult to reproduce, since they are only noticeable in very specific interactions. In addition, there are different concurrency models, which are increasingly combined in one and the same program. The topic of our research was therefore the development of a novel software infrastructure which allows parallel programs to be better analysed at runtime and thus sporadically occurring problems to be localised. The idea behind our approach is to record the behaviour of the programs and their interactions and to analyse these "traces" afterwards. The challenge here was to reconcile different concurrency models, i.e. to find a uniform recording technique for all these models that on the one hand allows parallel programs to be replayed in such a way that the same interactions occur as in the original execution, and on the other hand to make these recordings as compact and efficient as possible so that the execution of the programs is slowed down as little as possible. This record & replay approach was successfully implemented and published in 22 papers in international journals and conferences. The software infrastructure and the tools based on it were made available in an open source repository and now serve other researchers as a basis for further investigations. The required efficiency was achieved-among other things-by novel dynamic optimisation techniques. To ensure continuous recording of long-running programs, a snapshotting technique was developed with which a program's state can be captured at certain points in time, so that the analysis can start at these snapshots without having to consider earlier program traces. The project was a cooperation between the Johannes Kepler University Linz and the Vrije Universiteit Brussel. While the Linz group was mainly concerned with the efficient recording of parallel programs and their subsequent analysis, the Brussels group mainly researched parallelisation models and analysis tools, for example to be able to replay parallel programs forwards and backwards while analysing them.