What change history tells us about thread synchronization

Gu, Rui; Jin, Guoliang; Song, Linhai; Zhu, Lin; Lu, Shan

doi:10.1145/2786805.2786815

Cited by 31 publications

(10 citation statements)

References 81 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Performance issues of multithreaded programs, despite being the primary cause of more than 22% synchronization fixes of server programs [23], get less attention than they deserve. There are many prior works [8,19,21,23,28,41,43] in this domain, but none of them systematically investigates performance issues related to different types of synchronization primitives. Most existing works cannot identify root causes, and provide helpful fixing strategies.…”

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

SyncPerf

Alam

Liu

Zeng³

et al. 2017

Proceedings of the Twelfth European Conference on Computer Systems

View full text Add to dashboard Cite

Despite the obvious importance, performance issues related to synchronization primitives are still lacking adequate attention. No literature extensively investigates categories, root causes, and fixing strategies of such performance issues. Existing work primarily focuses on one type of problems, while ignoring other important categories. Moreover, they leave the burden of identifying root causes to programmers. This paper first conducts an extensive study of categories, root causes, and fixing strategies of performance issues related to explicit synchronization primitives. Based on this study, we develop two tools to identify root causes of a range of performance issues. Compare with existing work, our proposal, SyncPerf, has three unique advantages. First, SyncPerf's detection is very lightweight, with 2.3% performance overhead on average. Second, SyncPerf integrates information based on callsites, lock variables, and types of threads. Such integration helps identify more latent problems. Last but not least, when multiple root causes generate the same behavior, SyncPerf provides a second analysis tool that collects detailed accesses inside critical sections and helps identify possible root causes. SyncPerf discovers many unknown but significant synchronization performance issues. Fixing them provides a performance gain anywhere from 2.5% to 42%. Low overhead, better coverage, and informative reports make SyncPerf an effective tool to find synchronization performance bugs in the production environment. ⇤ Alam and Liu contributed equally to this work.

show abstract

Section: Introductionmentioning

confidence: 99%

“…Prior work [8,19,21,23,28,41,43] focuses excessively on locks that are both acquired frequently and highly contended. Our first observation is that performance problems can also occur with locks that are not excessively acquired or highly contended.…”

Section: Introductionmentioning

confidence: 99%

SyncPerf

Alam

Liu

Zeng³

et al. 2017

Proceedings of the Twelfth European Conference on Computer Systems

View full text Add to dashboard Cite

show abstract

“…Several approaches analyze concurrency-related performance issues [12,22,45,62,66,66]. For example, SpeedGun [45] generates multi-threaded performance test cases to expose performance differences between two program versions.…”

Section: Related Workmentioning

confidence: 99%

“…Since these two goals, correctness and performance, are often contradictory, developers struggle to achieve both. A recent study reports that more than 25% of all critical sections (CSs) are changed at some point by the developers, both to fix correctness bugs and to enhance performance [22]. Another study shows that unnecessary synchronization is a common root cause for real-world performance problems [26].…”

Section: Introductionmentioning

confidence: 99%

SyncProf: detecting, localizing, and optimizing synchronization bottlenecks

Pradel

2016

Proceedings of the 25th International Symposium on Software Testing and Analysis

View full text Add to dashboard Cite

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.

show abstract

“…As illustrated by the example from Figures 1 and 2, programming with implicit monitors is considerably easier because the programmer does not need to reason about when and which threads should be notified. In fact, it is well-known that many concurrency bugs are caused by erroneous signal placement in explicit-signal implementations [23,32]. However, despite their easier programmability, implicit-signal monitors are not widely-used due to performance considerations.…”

Section: Introductionmentioning

confidence: 99%

Symbolic reasoning for automatic signal placement

Ferles

Geffen

Dillig

et al. 2018

Proceedings of the 39th ACM SIGPLAN Conference on Programming Language Design and Implementation

View full text Add to dashboard Cite

Explicit signaling between threads is a perennial cause of bugs in concurrent programs. While there are several runtime techniques to automatically notify threads upon the availability of some shared resource, such techniques are not widely-adopted due to their run-time overhead. This paper proposes a new solution based on static analysis for automatically generating a performant explicit-signal program from its corresponding implicit-signal implementation. The key idea is to generate verification conditions that allow us to minimize the number of required signals and unnecessary context switches, while guaranteeing semantic equivalence between the source and target programs. We have implemented our method in a tool called Expresso and evaluate it on challenging benchmarks from prior papers and open-source software. Expresso-generated code significantly outperforms past automatic signaling mechanisms (avg. 1.56x speedup) and closely matches the performance of hand-optimized explicit-signal code. CCS Concepts • Software and its engineering → Concurrent programming languages; Concurrent programming structures;

show abstract

What change history tells us about thread synchronization

Cited by 31 publications

References 81 publications

SyncPerf

SyncPerf

SyncProf: detecting, localizing, and optimizing synchronization bottlenecks

Symbolic reasoning for automatic signal placement

Contact Info

Product

Resources

About