Titelaufnahme

Concurrent programming can lead to considerable performance gains on modern, parallel hardware when compared to single-core systems. When dealing with parallelization, however, developers have to explicitly address synchronization to safely access shared resources, which is typically achieved with locks. Choosing between simpler but less scalable and more sophisticated but error-prone locking mechanisms is difficult during development. Therefore, lock contention analysis at run time is crucial to aid in such decisions. We present a novel sampling-based approach for collecting detailed information on lock contention in Java applications. Our approach enables us to detect potential concurrency issues where threads have to wait unnecessarily. Our implementation only relies on the Java Virtual Machine Tool Interface (JVMTI) and on bytecode instrumentation. We support both intrinsic locks as well as java.util.concurrent locks. Moreover, we can determine not only where contention occurs, but also where it is caused. With a mean run-time overhead of about 5%, a low amount of data output and a high accuracy, we consider our approach suitable for use in production environments.

Auf moderner, paralleler Hardware können nebenläufige Programme oft erhebliche Performancegewinne gegenüber Single-Core-Systemen erzielen. Die Parallelisierung von Programmen macht es jedoch nötig, Zugriffe auf gemeinsame Daten zu synchronisieren, was normalerweise mittels Locks erreicht wird. Dabei muss man sich oft zwischen einfacheren, aber weniger skalierbaren, und ausgefeilteren, aber fehleranfälligen Lock-Mechanismen entscheiden, was oft schwer ist. In solchen Fällen ist die Laufzeitanalyse von Lock-Belegungscharakteristiken (lock contention analysis) äußerst hilfreich. Wir präsentieren einen neuartigen, stichprobenbasierten Ansatz, um detaillierte Informationen über Lock Contention in Java-Applikationen zu sammeln. Die Analyse erlaubt uns, potentielle Nebenläufigkeitsprobleme zu erkennen, bei denen Threads unnötigerweise warten müssen. Unsere Implementierung basiert auf dem Java Virtual Machine Tool Interface (JVMTI) und auf Bytecode-Instrumentierung. Wir unterstützen sowohl Intrinsic Locks als auch java.util.concurrent Locks. Außerdem können wir nicht nur feststellen, wo Contention auftritt, sondern auch, wo sie verursacht wird. In Anbetracht eines durchschnittlichen Laufzeitmehraufwandes von etwa 5%, geringer Output-Datenmenge und einer hohen Genauigkeit ist unser Verfahren für den Einsatz in Produktionsumgebungen geeignet.