PDF, English Download (3MB) | Terms of use

Abstract

Software systems are an integral part of modern society. As we continue to harness software automation in all aspects of our daily lives, the runtime performance of these systems become increasingly important. When everything seems just a click away, performance issues that compromise the responsiveness of a system can lead to severe financial and reputation losses. Designing efficient code is critical for ensuring good and consistent performance of software systems. It requires performance expertize, and encompasses a set of difficult design decisions that need to be continuously revisited throughout the evolution of the software. Developers must test the performance of their core implementations, select efficient data structures and algorithms, explore parallel processing when it provides performance benefits, among many other aspects. Furthermore, the constant pressure for high-productivity laid on developers, aligned with the increasing complexity of modern software, makes designing efficient code an even more challenging endeavor.

This thesis presents a series of novel approaches based on empirical insights that attempt to support developers at the task of designing efficient code. We present contributions in three aspects. First, we investigate the prevalence and impact of bad practices on performance benchmarks of Java-based open-source software. We show that not only these bad practices occur frequently, they often distort the benchmark results substantially. Moreover, we devise a tool that can be used by developers to identify bad practices during benchmark creation automatically.

Second, we design an application-level framework that identifies suboptimal implementations and selects optimized variants at runtime, effectively optimizing the execution time and memory usage of the target application. Furthermore, we investigate the performance of data structures from several popular collection libraries. Our findings show that alternative variants can be selected for substantial performance improvement under specific usage scenarios.

Third, we investigate the parallelization of object processing via Java streams. We propose a decision-support framework that leverages machine-learning models trained through a series of benchmarks, to identify and report stream pipelines that should be processed in parallel for better performance.

Translation of abstract (German)

Softwaresysteme sind integraler Bestandteil der modernen Gesellschaft. Die immer weitere Durchdringung aller Bereiche des täglichen Lebens durch die Automation durch Software macht das Laufzeitverhalten dieser Systeme immer wichtiger. Wenn alles nur einen Klick entfernt scheint, können Leistungsprobleme, die die Reaktionsfähigkeit eines Systems beeinträchtigen, schwere finanzielle Schäden verursachen sowie rufschädigend wirken. Effizienten Code zu entwerfen ist kritisch wichtig um gute und gleichmäßige Leistung von Softwaresystemen sicherzustellen. Das erfordert Expertise in Softwareleistung, und beinhaltet schwierige Designentscheidungen, die immer wieder überdacht werden müssen, während die Software ihrer Evolution unterliegt. Entwickler müssen die Leistungsfähigkeit ihrer zentralen Implementationen testen, effiziente Datenstrukturen und Algorithmen wählen, parallele Verarbeitung in Erwägung ziehen, falls dies Leistungsgewinne verspricht; neben vielen anderen Gesichtspunkten. Weiterhin macht der konstante Erwartungsdruck hoher Produktivität, der auf Entwicklern lastet, sowie die anwachsende Komplexität moderner Software den Entwurf von effizientem Code zu einer umso größeren Herausforderung.

Diese Arbeit stelle eine Reihe neuartiger, auf empirischen Einsichten beruhender Ansätze vor, die Entwickler beim Entwurf effizienten Codes unterstützen sollen. Wir präsentieren Beiträge in drei Bereichen. Erstens untersuchen wir die Verbreitung von schlechten Programmierpraktiken und ihren Auswirkungen auf Leistungsbenchmarks von Java-basierter Open-Source-Software. Wir zeigen nicht nur dass diese schlechte Praktiken häufig vorkommen, sondern sogar oft die Benchmarkergebnisse erheblich beeinträchtigen. Außerdem entwickeln wir ein Tool, das von Entwicklern genutzt werden kann, um schlechte Praktiken während der Benchmarkerstellung automatisch zu erkennen.

Zweitens entwerfen wir ein Framework auf Anwendungsebene, das suboptimale Implementationen erkennt und optimierte Varianten zur Laufzeit wählt, und so effektiv die Ausführungszeit und den Speicherverbrauch der Zielanwendung optimiert. Weiterhin untersuchen wir die Leistung von Datenstrukturen aus verschiedenen populären Programmierbibliotheken für Collections. Unsere Ergebnisse zeigen, dass alternative Varianten so ausgewählt werden können, dass bedeutende Leistungsgewinne unter bestimmten Gegebenheiten erzielt werden können.

Drittens untersuchen wir die Parallelisierung von Objekt-Verarbeitung mittels Java-Streams. Wir stellen ein Framework zur Unterstützung von Entscheidungen vor, das Modelle des maschinellen Lernens nutzt, die mit einer Reihe von Benchmarks trainiert werden, und so Stream-Pipelines erkennt und meldet, die durch Parallelisierung mit höherer Leistung verarbeitet werden können.