GRace: A low-overhead mechanism for detecting data races in gpu programs

Mai Zheng, Vignesh T. Ravi, Feng Qin, Gagan Agrawal

Research output: Contribution to journalArticlepeer-review

23 Scopus citations

Abstract

In recent years, GPUs have emerged as an extremely cost-effective means for achieving high performance. Many application developers, including those with no prior parallel programming experience, are now trying to scale their applications using GPUs. While languages like CUDA and OpenCL have eased GPU programming for non-graphical applications, they are still explicitly parallel languages. All parallel programmers, particularly the novices, need tools that can help ensuring the correctness of their programs. Like any multithreaded environment, data races on GPUs can severely affect the program reliability. Thus, tool support for detecting race conditions can significantly benefit GPU application developers. Existing approaches for detecting data races on CPUs or GPUs have one or more of the following limitations: 1) being illsuited for handling non-lock synchronization primitives on GPUs; 2) lacking of scalability due to the state explosion problem; 3) reporting many false positives because of simplified modeling; and/or 4) incurring prohibitive runtime and space overhead. In this paper, we propose GRace, a new mechanism for detecting races in GPU programs that combines static analysis with a carefully designed dynamic checker for logging and analyzing information at runtime. Our design utilizes GPUs memory hierarchy to log runtime data accesses efficiently. To improve the performance, GRace leverages static analysis to reduce the number of statements that need to be instrumented. Additionally, by exploiting the knowledge of thread scheduling and the execution model in the underlying GPUs, GRace can accurately detect data races with no false positives reported. Based on the above idea, we have built a prototype of GRace with two schemes, i.e., GRace-stmt and GRace-addr, for NVIDIA GPUs. Both schemes are integrated with the same static analysis. We have evaluated GRace-stmt and GRace-addr with three data race bugs in three GPU kernel functions and also have compared them with the existing approach, referred to as B-tool. Our experimental results show that both schemes of GRace are effective in detecting all evaluated cases with no false positives, whereas Btool reports many false positives for one evaluated case. On the one hand, GRace-addr incurs low runtime overhead, i.e., 22-116%, and low space overhead, i.e., 9-18 MB, for the evaluated kernels. On the other hand, GRace-stmt offers more help in diagnosing data races with larger overhead.

Original languageEnglish (US)
Pages (from-to)135-145
Number of pages11
JournalACM SIGPLAN Notices
Volume46
Issue number8
DOIs
StatePublished - Aug 2011
Externally publishedYes
Eventthe 16th ACM symposium - San Antonio, TX, USA
Duration: Feb 12 2011Feb 16 2011

Keywords

  • Concurrency
  • CUDA
  • Data Race
  • GPU
  • Multithreading

ASJC Scopus subject areas

  • Computer Science(all)

Fingerprint

Dive into the research topics of 'GRace: A low-overhead mechanism for detecting data races in gpu programs'. Together they form a unique fingerprint.

Cite this