2020 · IEEE International Symposium on Software Reliability Engineering Workshops (ISSREW)
Multi-Level Execution Trace Based Lock Contention Analysis
Evidence basis: metadata-only · Review status: catalog-reviewed; paper-author approval pending
kernel-tracing system-tracing performance-analysis root-cause-analysis
lock contention multi-level execution traces LTTng 2.10 Trace Compass 4 LD_PRELOAD Pthreads futex spinlock semaphore critical path state system Apache OPcache
Core contribution: The paper extends critical-path analysis across kernel and user-space lock events so contention from futexes, spinlocks, semaphores, and other synchronization mechanisms can be diagnosed without recompiling the application.
Problem and motivation
Kernel-only analysis misses locks implemented in user space, while source-dependent tools are difficult to apply to large multi-threaded applications and cannot provide a unified view of cross-level dependencies.
Method and contribution
LTTng 2.10 and Trace Compass 4 collect kernel futex events and user-space Pthreads wrapper events injected with LD_PRELOAD. The method maps events to state intervals in a tree-based state system, constructs a sparse execution graph with horizontal running edges and vertical blocking edges, and recursively replaces waiting edges with waking-thread edges to extract a multi-level active path. Wait-block, flame-graph, critical-flow, and state views expose the result.
Findings and evidence
A C++ Pthreads evaluation covers spinlock and semaphore contention. User-space lock-event tracing adds less than 0.7% execution-time overhead; enabling all kernel events can impose up to 25%, while the minimal event set for lock analysis is reported at about 7%. In Apache, the method isolates user-space file-lock waits and connects anomalous latency to OPcache shared-cache contention during concurrent script compilation.
Limitations and future directions
Limitations: The evidence covers C++ and Apache/PHP cases and shows that kernel overhead is highly event-set dependent; it does not establish broad language, workload, or distributed-deployment generalization. The reviewed conclusion does not specify a concrete author-stated future-work agenda.
Future work: No detailed future-work direction is stated in the reviewed conclusion; further extensions should be treated as proposed follow-up rather than as author claims.
Sources and identifiers
- Published version published
When to cite this paper
Cite this paper when diagnosing lock contention across kernel and user-space synchronization mechanisms without recompiling the application.
- LTTng 2.10, Trace Compass 4, futex events, and LD_PRELOAD Pthreads wrappers.
- Multi-level execution graphs and active paths for mutex, spinlock, and semaphore dependencies.
- C++ and Apache/OPcache cases with minimal-tracing overhead and full-kernel-event overhead bounds.
Citation
@inproceedings{ezzatiJivan2020multilevel,
author = {Majid Rezazadeh and Naser Ezzati-Jivan and Evan Galea and Michel R. Dagenais},
title = {Multi-Level Execution Trace Based Lock Contention Analysis},
year = {2020},
booktitle = {IEEE International Symposium on Software Reliability Engineering Workshops (ISSREW)},
pages = {177-182},
publisher = {IEEE},
doi = {10.1109/issrew51248.2020.00068},
url = {https://doi.org/10.1109/issrew51248.2020.00068}
}Other citation formats for Word and reference managers
Rezazadeh, M., Ezzati-Jivan, N., Galea, E., & Dagenais, M. R. (2020). Multi-Level Execution Trace Based Lock Contention Analysis. In IEEE International Symposium on Software Reliability Engineering Workshops (ISSREW) (pp. 177-182). https://doi.org/10.1109/issrew51248.2020.00068M. Rezazadeh, N. Ezzati-Jivan, E. Galea, and M. R. Dagenais, "Multi-Level Execution Trace Based Lock Contention Analysis," in IEEE International Symposium on Software Reliability Engineering Workshops (ISSREW), pp. 177-182, 2020, doi: 10.1109/issrew51248.2020.00068