SyncProf: detecting, localizing, and optimizing synchronization bottlenecks

Abstract

Writing concurrent programs is a challenge because developers must consider both functional correctness and performance requirements. Numerous program analyses and testing techniques have been proposed to detect functional faults, e.g., caused by incorrect synchronization. However, little work has been done to help developers address performance problems in concurrent programs, e.g., because of inefficient synchronization. This paper presents SyncProf, a concurrency-focused profiling approach that helps in detecting, localizing, and optimizing synchronization bottlenecks. In contrast to traditional profilers, SyncProf repeatedly executes a program with various inputs and summarizes the observed performance behavior. A key novelty is a graph-based representation of relations between critical sections, which is the basis for computing the performance impact of critical sections, for identifying the root cause of a bottleneck, and for suggesting optimization strategies to the developer. We evaluate SyncProf on 19 versions of eight C/C++ projects with both known and previously unknown synchronization bottlenecks. The results show that SyncProf effectively localizes the root causes of these bottlenecks with higher precision than a state of the art lock contention profiler and that it suggests valuable strategies to avoid the bottlenecks.

Inferring Performance Bug Patterns from Developer Commits

“…Synchronization problems are the least common performance bug pattern fixed in the investigated commits. Synchronization related performance bugs, in particular those related to lock contention, have been addressed by previous research [5]- [7]. This work, however, is relatively new and we do not expect the developed techniques to be already part of the standard tool set of open source developers.…”

“…In C/C++ projects, mutex-like locks are the most commonly used synchronization primitives, while spinlocks are widely used in operating system kernels. Since a mutex may block the execution of the program, low CPU utilization could be regarded as a rudimentary indicator of possible performance problems [5]. Besides CPU utilization, developers nowadays also profile the waiting time of each thread on a lock [6], [7] to localize where locks are mostly contended.…”

“…From the commits we investigated, our impression is that synchronization related performance bugs either are a relatively rare occurrence or that they just do not get detected and fixed. Firefox, for instance, was once a project suffering synchronization related performance bugs [5] while in our investigation no synchronization problems have been sampled. Another example is linux, where the synchronization fixes in the sampled commits are not related to lock contentions, but substitute locks with lockless RCUs [36].…”

Analysis and Optimization of Task Granularity on the Java Virtual Machine

“…SyncProf [148] locates portions of code where bottlenecks are caused by threads suffering from contention and synchronization issues. SyncProf repeatedly executes a program with various inputs and summarizes the observed performance behavior with a graph-based representation that relates different critical sections.…”

Systematic black-box analysis of collaborative web applications

“…Complementary to generating concurrent tests, there is work on creating multi-threaded performance regression tests [31], which is orthogonal to the problem addressed here. races [5,12,24] and atomicity violations [2,15,40], static analyses [17,28,47], and profilers to detect synchronizationrelated performance bottlenecks [48]. In contrast to these approaches, Simian is a black-box analysis that does not require low-level reasoning about the application code.…”