With greater adoption of various high-level parallel programming models to harness on-node parallelism, accurate data race detection has become more crucial than ever. However, existing tools have great difficulty spotting data races through these high-level models, as they primarily target low-level concurrent execution models (e.g., concurrency expressed at the level of POSIX threads). In this paper, we propose a novel technique to accurately detect those data races that can occur at higher levels of concurrent execution. The core idea of our technique is to introduce the general concept of Thread-Local Concurrency (TLC) as a new way to translate the concurrency expressed by a high-level programming paradigm into the low execution level understood by the existing tools. Specifically, we extend the definition of vector clocks to allow the existing state-of-the-art race detectors to recognize those races that occur at the higher level of concurrency with minor modifications to these tools. Our evaluation with our prototype implemented within ThreadSanitizer shows that TLC can allow the existing tool to detect these races accurately with only small additional analysis overheads.
%0 Conference Paper
%1 Protze:2018:TCT
%A Protze, Joachim
%A Schulz, Martin
%A Ahn, Dong H.
%A Müller, Matthias S.
%B Proceedings of the 27th International Symposium on High-Performance Parallel and Distributed Computing
%D 2018
%I ACM
%K Asynchronous C Combination Concurrency DataRaces Dependencies ForkJoin HPC MessagePassing Model OpenMP Races Tasks ThreadLocal
%P 144--155
%R 10.1145/3208040.3208056
%T Thread-local Concurrency: A Technique to Handle Data Race Detection at Programming Model Abstraction
%X With greater adoption of various high-level parallel programming models to harness on-node parallelism, accurate data race detection has become more crucial than ever. However, existing tools have great difficulty spotting data races through these high-level models, as they primarily target low-level concurrent execution models (e.g., concurrency expressed at the level of POSIX threads). In this paper, we propose a novel technique to accurately detect those data races that can occur at higher levels of concurrent execution. The core idea of our technique is to introduce the general concept of Thread-Local Concurrency (TLC) as a new way to translate the concurrency expressed by a high-level programming paradigm into the low execution level understood by the existing tools. Specifically, we extend the definition of vector clocks to allow the existing state-of-the-art race detectors to recognize those races that occur at the higher level of concurrency with minor modifications to these tools. Our evaluation with our prototype implemented within ThreadSanitizer shows that TLC can allow the existing tool to detect these races accurately with only small additional analysis overheads.
%@ 978-1-4503-5785-2
@inproceedings{Protze:2018:TCT,
abstract = {With greater adoption of various high-level parallel programming models to harness on-node parallelism, accurate data race detection has become more crucial than ever. However, existing tools have great difficulty spotting data races through these high-level models, as they primarily target low-level concurrent execution models (e.g., concurrency expressed at the level of POSIX threads). In this paper, we propose a novel technique to accurately detect those data races that can occur at higher levels of concurrent execution. The core idea of our technique is to introduce the general concept of Thread-Local Concurrency (TLC) as a new way to translate the concurrency expressed by a high-level programming paradigm into the low execution level understood by the existing tools. Specifically, we extend the definition of vector clocks to allow the existing state-of-the-art race detectors to recognize those races that occur at the higher level of concurrency with minor modifications to these tools. Our evaluation with our prototype implemented within ThreadSanitizer shows that TLC can allow the existing tool to detect these races accurately with only small additional analysis overheads.},
acmid = {3208056},
added-at = {2018-08-22T19:42:08.000+0200},
author = {Protze, Joachim and Schulz, Martin and Ahn, Dong H. and M\"{u}ller, Matthias S.},
biburl = {https://www.bibsonomy.org/bibtex/251186ef452757d0c4827f3c774dffa7f/gron},
booktitle = {Proceedings of the 27th International Symposium on High-Performance Parallel and Distributed Computing},
description = {Thread-local concurrency},
doi = {10.1145/3208040.3208056},
interhash = {91785ba54f1d2838464e90e37d9ea2ed},
intrahash = {51186ef452757d0c4827f3c774dffa7f},
isbn = {978-1-4503-5785-2},
keywords = {Asynchronous C Combination Concurrency DataRaces Dependencies ForkJoin HPC MessagePassing Model OpenMP Races Tasks ThreadLocal},
location = {Tempe, Arizona},
numpages = {12},
pages = {144--155},
publisher = {ACM},
series = {HPDC'18},
timestamp = {2018-08-22T19:42:08.000+0200},
title = {{Thread-local Concurrency: A Technique to Handle Data Race Detection at Programming Model Abstraction}},
year = 2018
}