2019 · Journal of Systems Architecture
Efficient Large-Scale Heterogeneous Debugging Using Dynamic Tracing
Evidence basis: full-text-reviewed · Review status: catalog-reviewed; paper-author approval pending
system-tracing trace-analysis performance-analysis root-cause-analysis
heterogeneous systems dynamic tracing large-scale debugging debugging efficiency GDB LTTng-UST Trace Compass ROCm-GDB GPU debugging pbzip2
Core contribution: The paper redesigns GDB dynamic tracing around LTTng-UST and scalable trace views so multi-threaded CPU/GPU debugging remains usable on heterogeneous many-core systems.
Problem and motivation
Conventional debugger tracing serializes many threads through shared buffers and stop-the-world flushing, while heterogeneous CPU/GPU execution produces too many threads, waves, and call-stack events for a flat debugger UI.
Method and contribution
Dynamically insert jump-pad instrumentation from GDB/GDBServer and transfer events through LTTng-UST per-core lock-free-style ring buffers without stopping the target during buffer transfer. Trace Compass aggregates CPU call stacks and provides hierarchical HSA GPU wave/grid views and filters.
Findings and evidence
The proposed path scales substantially better than default GDB fast tracing on the pbzip2 workload, with much lower growth in tracing overhead as thread count increases. The UI supports focused CPU call-stack and GPU wave-level exploration.
Limitations and future directions
Limitations: Instrumentation has instruction-size/location constraints; filters still incur event/context-switch cost; GPU first-level grouping may require manual expansion; closed-source tools were excluded; the evaluation centers on pbzip2 and one GPU setup, with only informal feedback from three engineers rather than a controlled user study.
Future work: No dedicated future-work section is provided. The conclusion identifies a cautious next direction: remove the size limitation by replacing a function frame and instrumenting that frame.
Sources and identifiers
- Published version published
- Public full text · PDF public_full_text
When to cite this paper
Cite this paper when your work uses or compares combining dynamic GDB jump-pad instrumentation with per-core LTTng-UST buffers to avoid the default shared-buffer/flush bottleneck.
- For combining dynamic GDB jump-pad instrumentation with per-core LTTng-UST buffers to avoid the default shared-buffer/flush bottleneck.
- For the pbzip2 scaling result showing proposed tracing at about 90% overhead versus 3294% for the default path at 15 threads.
- For hierarchical CPU call-stack and HSA GPU grid/wave navigation in a heterogeneous debugging interface.
- For the practical limitations of x86-64 jump-pad placement and GPU event filtering under dynamic tracing.
Citation
@article{ezzatiJivan2019efficientlarge,
author = {Didier Nadeau and Naser Ezzati-Jivan and Michel R. Dagenais},
title = {Efficient Large-Scale Heterogeneous Debugging Using Dynamic Tracing},
year = {2019},
journal = {Journal of Systems Architecture},
volume = {98},
pages = {346-360},
publisher = {Elsevier BV},
issn = {1383-7621},
doi = {10.1016/j.sysarc.2019.02.016},
url = {https://doi.org/10.1016/j.sysarc.2019.02.016}
}Other citation formats for Word and reference managers
Nadeau, D., Ezzati-Jivan, N., & Dagenais, M. R. (2019). Efficient Large-Scale Heterogeneous Debugging Using Dynamic Tracing. Journal of Systems Architecture, 98, 346-360. https://doi.org/10.1016/j.sysarc.2019.02.016D. Nadeau, N. Ezzati-Jivan, and M. R. Dagenais, "Efficient Large-Scale Heterogeneous Debugging Using Dynamic Tracing," Journal of Systems Architecture, vol. 98, pp. 346-360, 2019, doi: 10.1016/j.sysarc.2019.02.016