Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
skip to main content
research-article
Open access

Sound and Partially-Complete Static Analysis of Data-Races in GPU Programs

Published: 08 October 2024 Publication History

Abstract

GPUs are progressively being integrated into modern society, playing a pivotal role in Artificial Intelligence and High-Performance Computing. Programmers need a deep understanding of the GPU programming model to avoid subtle data-races in their codes. Static verification that is sound and incomplete can guarantee data-race freedom, but the alarms it raises may be spurious and need to be validated.
In this paper, we establish a True Positive Theorem for a static data-race detector for GPU programs, i.e., a result that identifies a class of programs for which our technique only raises true alarms. Our work builds on the formalism of memory access protocols, that models the concurrency operations of CUDA programs. The crux of our approach is an approximation analysis that can correctly identify true alarms, and pinpoint the conditions that make an alarm imprecise. Our approximation analysis detects when the reported locations are reachable (control independence, or CI), and when the reported locations are precise (data independence, or DI), as well identify inexact values in an alarm. In addition to a True Positive result for programs that are CI and DI, we establish the root causes of spurious alarms depending on whether CI or DI are present.
We apply our theory to introduce FaialAA, the first sound and partially complete data-race detector. We evaluate FaialAA in three experiments. First, in a comparative study with the state-of-the-art tools, we show that FaialAA confirms more DRF programs than others while emitting 1.9× fewer potential alarms. Importantly, the approximation analysis of FaialAA detects 10 undocumented data-races. Second, in an experiment studying 6 commits of data-race fixes in open source projects OpenMM and Nvidia’s MegaTron, FaialAA confirmed the buggy and fixed versions of 5 commits, while others were only able to confirm 2. Third, we show that 59.5% of 2,770 programs are CI and DI, quantifying when the approximation analysis of FaialAA is complete.
This paper is accompanied by the mechanized proofs of the theoretical results presented therein and a tool (FaialAA) implementing of our theory.

References

[1]
Rajeev Alur, Joseph Devietti, Omar S. Navarro Leija, and Nimit Singhania. 2017. GPUDrano: Detecting Uncoalesced Accesses in GPU Programs. In Proceedings of CAV (LNCS, Vol. 10426). Springer, Berlin, Heidelberg. 507–525. https://doi.org/10.1007/978-3-319-63387-9_25
[2]
Rajeev Alur, Joseph Devietti, Omar S. Navarro Leija, and Nimit Singhania. 2022. Static detection of uncoalesced accesses in GPU programs. Formal Methods in System Design, 60 (2022), 1–32. issn:1572-8102 https://doi.org/10.1007/s10703-021-00362-8
[3]
Steven Arzt, Siegfried Rasthofer, Robert Hahn, and Eric Bodden. 2015. Using Targeted Symbolic Execution for Reducing False-Positives in Dataflow Analysis. In Proceedings of SOAP. ACM, New York, NY, USA. 1–6. isbn:9781450335850 https://doi.org/10.1145/2771284.2771285
[4]
Ali Bakhoda, George L. Yuan, Wilson W. L. Fung, Henry Wong, and Tor M. Aamodt. 2009. Analyzing CUDA workloads using a detailed GPU simulator. In Proceedings of ISPASS. IEEE, Piscataway, NJ, USA. 163–174. https://doi.org/10.1109/ISPASS.2009.4919648
[5]
Thomas Ball and Sriram K. Rajamani. 2001. Automatically Validating Temporal Safety Properties of Interfaces. In Proceedings of SPIN. Springer, Berlin, Heidelberg. 103–122. isbn:3540421246 https://doi.org/10.1007/3-540-45139-0_7
[6]
Ethel Bardsley, Adam Betts, Nathan Chong, Peter Collingbourne, Pantazis Deligiannis, Alastair F. Donaldson, Jeroen Ketema, Daniel Liew, and Shaz Qadeer. 2014. Engineering a Static Verification Tool for GPU Kernels. In Proceedings of CAV. 8559, Springer, Berlin, Heidelberg. 226–242. isbn:978-3-319-08866-2 https://doi.org/10.1007/978-3-319-08867-9_15
[7]
Ethel Bardsley, Alastair F. Donaldson, and John Wickerson. 2014. KernelInterceptor: Automating GPU Kernel Verification by Intercepting Kernels and their Parameters. In Proceedings of IWOCL. ACM, New York, NY, USA. Article 7, 5 pages. https://doi.org/10.1145/2664666.2664673
[8]
Ken E. Batcher. 1968. Sorting networks and their applications. In Proceedings of AFIPS. ACM, New York, NY, USA. 307–314. isbn:9781450378970 https://doi.org/10.1145/1468075.1468121
[9]
Adam Betts, Nathan Chong, Alastair F. Donaldson, Jeroen Ketema, Shaz Qadeer, Paul Thomson, and John Wickerson. 2015. The Design and Implementation of a Verification Technique for GPU Kernels. Transactions on Programming Languages and Systems, 37, 3 (2015), Article 10, 49 pages. issn:0164-0925 https://doi.org/10.1145/2743017
[10]
Adam Betts, Nathan Chong, Alastair F. Donaldson, Shaz Qadeer, and Paul Thomson. 2012. GPUVerify: a Verifier for GPU Kernels. In Proceedings of OOPSLA. ACM, New York, NY, USA. 113–132. https://doi.org/10.1145/2384616.2384625
[11]
Stefan Blom, Marieke Huisman, and Matej Mihelčić. 2014. Specification and Verification of GPGPU Programs. Science of Computer Programming, 95, P3 (2014), 376–388. issn:0167-6423 https://doi.org/10.1016/j.scico.2014.03.013
[12]
Marco Campion, Mila Dalla Preda, and Roberto Giacobazzi. 2022. Partial (In)Completeness in abstract interpretation: limiting the imprecision in program analysis. Proceedings of the ACM Programming Languages, 6, POPL (2022), Article 59, 31 pages. https://doi.org/10.1145/3498721
[13]
Prasanth Chatarasi, Jun Shirako, Martin Kong, and Vivek Sarkar. 2017. An Extended Polyhedral Model for SPMD Programs and Its Use in Static Data Race Detection. In Proceedings of LCPC’16. Springer, Berlin, Heidelberg. 106–120. isbn:978-3-319-52709-3 https://doi.org/10.1007/978-3-319-52709-3_10
[14]
Bharti Chimdyalwar, Priyanka Darke, Anooj Chavda, Sagar Vaghani, and Avriti Chauhan. 2015. Eliminating Static Analysis False Positives Using Loop Abstraction and Bounded Model Checking. In Proceedings FM. Springer, Cham. 573–576. isbn:978-3-319-19249-9 https://doi.org/10.1007/978-3-319-19249-9_35
[15]
Tiago Cogumbreiro, Julien Lange, Dennis Liew Zhen Rong, and Hannah Zicarelli. 2023. Memory Access Protocols: Certified Data-Race Freedom for GPU Kernels. FMSD, 38 pages. https://doi.org/10.1007/s10703-023-00415-0
[16]
Tiago Cogumbreiro, Julien Lange, Dennis Liew Zhen Rong, and Hannah Zicarelli. 2021. Checking Data-Race Freedom of GPU Kernels, Compositionally. In Proceedings of CAV (LNCS, Vol. 12759). ACM, New York, NY, USA. 403–426. https://doi.org/10.1007/978-3-030-81685-8_19
[17]
Peter Collingbourne, Cristian Cadar, and Paul H.J. Kelly. 2014. Symbolic Crosschecking of Data-Parallel Floating-Point Code. IEEE Transactions on Software Engineering, 40, 7 (2014), 710–737. https://doi.org/10.1109/TSE.2013.2297120
[18]
Peter Collingbourne, Cristian Cadar, and Paul H. J. Kelly. 2012. Symbolic Testing of OpenCL Code. In Proceedings of HVC. Springer, Berlin, Heidelberg. 203–218. isbn:978-3-642-34187-8 https://doi.org/10.1007/978-3-642-34188-5_18
[19]
Priyanka Darke, Bharti Chimdyalwar, Avriti Chauhan, and R. Venkatesh. 2017. Efficient Safety Proofs for Industry-Scale Code Using Abstractions and Bounded Model Checking. In Proceedings of ICST. IEEE, Piscataway, NJ, USA. 468–475. https://doi.org/10.1109/ICST.2017.53
[20]
Leonardo De Moura and Nikolaj Bjørner. 2008. Z3: An Efficient SMT Solver. In Proceedings of TACAS. Springer, Berlin, Heidelberg. 337–340. isbn:3540787992 https://doi.org/10.1007/978-3-540-78800-3_24
[21]
Lorenzo Dematté and Davide Prandi. 2010. GPU computing for systems biology. Briefings in Bioinformatics, 11, 3 (2010), 03, 323–333. issn:1477-4054 https://doi.org/10.1093/bib/bbq006
[22]
Peter Eastman, Jason Swails, John D. Chodera, Robert T. McGibbon, Yutong Zhao, Kyle A. Beauchamp, Lee-Ping Wang, Andrew C. Simmonett, Matthew P. Harrigan, Chaya D. Stern, Rafal P. Wiewiora, Bernard R. Brooks, and Vijay S. Pande. 2017. OpenMM 7: Rapid development of high performance algorithms for molecular dynamics. Computational Biology, 13, 7 (2017), 07, 1–17. https://doi.org/10.1371/journal.pcbi.1005659
[23]
Ariel Eizenberg, Yuanfeng Peng, Toma Pigli, William Mansky, and Joseph Devietti. 2017. BARRACUDA: Binary-level Analysis of Runtime RAces in CUDA Programs. In Proceedings of PLDI. ACM, New York, NY, USA. 126–140. isbn:978-1-4503-4988-8 https://doi.org/10.1145/3062341.3062342
[24]
Benjamin Ferrell, Jun Duan, and Kevin W. Hamlen. 2019. CUDA au Coq: A Framework for Machine-validating GPU Assembly Programs. In Proceedings of DATE. IEEE, Piscataway, NJ, USA. 474–479. https://doi.org/10.23919/DATE.2019.8715160
[25]
Mikhail R. Gadelha, Enrico Steffinlongo, Lucas C. Cordeiro, Bernd Fischer, and Denis A. Nicole. 2019. SMT-Based Refutation of Spurious Bug Reports in the Clang Static Analyzer. In Proceedings of ICSE-Companion. IEEE, Piscataway, NJ, USA. 11–14. https://doi.org/10.1109/ICSE-Companion.2019.00026
[26]
Pierre Ganty, Francesco Ranzato, and Pedro Valero. 2021. Complete Abstractions for Checking Language Inclusion. ACM Transactions on Computational Logic, 22, 4 (2021), Article 22, sep, 40 pages. issn:1529-3785 https://doi.org/10.1145/3462673
[27]
A. Yu. Gerasimov. 2018. Directed Dynamic Symbolic Execution for Static Analysis Warnings Confirmation. Programming and Computer Software, 44, 5 (2018), 316–323. issn:0361-7688 https://doi.org/10.1134/S036176881805002X
[28]
A. Yu. Gerasimov, L. V. Kruglov, M. K. Ermakov, and S. P. Vartanov. 2018. An Approach to Reachability Determination for Static Analysis Defects with the Help of Dynamic Symbolic Execution. Programming Computer Software, 44, 6 (2018), 467–475. issn:0361-7688 https://doi.org/10.1134/S0361768818060051
[29]
Roberto Giacobazzi, Francesco Logozzo, and Francesco Ranzato. 2015. Analyzing Program Analyses. In Proceedings of POPL. ACM, New York, NY, USA. 261—273. isbn:9781450333009 https://doi.org/10.1145/2676726.2676987
[30]
Nikos Gorogiannis, Peter W O’Hearn, and Ilya Sergey. 2019. A true positives theorem for a static race detector. Proceedings of the ACM on Programming Languages, 3, POPL (2019), 1–29. https://doi.org/10.1145/3290370
[31]
Thomas A. Henzinger, Ranjit Jhala, Rupak Majumdar, and Grégoire Sutre. 2002. Lazy Abstraction. In Proceedings of POPL. ACM, New York, NY, USA. 58–70. https://doi.org/10.1145/503272.503279
[32]
Anup Holey, Vineeth Mekkat, and Antonia Zhai. 2013. HAccRG: Hardware-Accelerated Data Race Detection in GPUs. In Proceedings of ICPP. IEEE, Piscataway, NJ, USA. 60–69. issn:0190-3918 https://doi.org/10.1109/ICPP.2013.15
[33]
John Jacobson, Martin Burtscher, and Ganesh Gopalakrishnan. 2024. HiRace: Accurate and Fast Data Race Checking for GPU Programs. In Proceedings of SC. IEEE, Piscataway, NJ, USA. 12 pages.
[34]
Zhen Hang Jiang, Yunsi Fei, and David Kaeli. 2019. Exploiting Bank Conflict-Based Side-Channel Timing Leakage of GPUs. ACM Transactions on Architecture and Code Optimization, 16, 4 (2019), Article 42, 24 pages. issn:1544-3566 https://doi.org/10.1145/3361870
[35]
Brittany Johnson, Yoonki Song, Emerson Murphy-Hill, and Robert Bowdidge. 2013. Why don’t software developers use static analysis tools to find bugs? In Proceedings of ICSE. IEEE, Piscataway, NJ, USA. 672–681. https://doi.org/10.1109/ICSE.2013.6606613
[36]
Ashwin Kallingal Joshy, Xueyuan Chen, Benjamin Steenhoek, and Wei Le. 2021. Validating Static Warnings via Testing Code Fragments. In Proceedings of ISSTA. ACM, New York, NY, USA. 540–552. isbn:9781450384599 https://doi.org/10.1145/3460319.3464832
[37]
Aditya K. Kamath, Alvin A. George, and Arkaprava Basu. 2020. ScoRD: A Scoped Race Detector for GPUs. In Proceedings of ISCA. IEEE, Piscataway, NJ, USA. 1036–1049. https://doi.org/10.1109/ISCA45697.2020.00088
[38]
Youil Kim, Jooyong Lee, Hwansoo Han, and Kwang-Moo Choe. 2010. Filtering False Alarms of Buffer Overflow Analysis Using SMT Solvers. Information and Software Technology, 52, 2 (2010), 210–219. issn:0950-5849 https://doi.org/10.1016/j.infsof.2009.10.004
[39]
Kensuke Kojima and Atsushi Igarashi. 2013. A Hoare Logic for SIMT Programs. In Proceedings of APLAS. 8301, Springer, Berlin, Heidelberg. 58–73. isbn:978-3-319-03541-3 https://doi.org/10.1007/978-3-319-03542-0_5
[40]
Kensuke Kojima and Atsushi Igarashi. 2017. A Hoare Logic for GPU Kernels. Transactions on Computational Logic, 18, 1 (2017), Article 3, 43 pages. issn:1529-3785 https://doi.org/10.1145/3001834
[41]
Kensuke Kojima, Akifumi Imanishi, and Atsushi Igarashi. 2018. Automated Verification of Functional Correctness of Race-Free GPU Programs. Journal of Automated Reasoning, 60, 3 (2018), 279–298. issn:0168-7433 https://doi.org/10.1007/s10817-017-9428-2
[42]
Vijay Anand Korthikanti, Jared Casper, Sangkug Lym, Lawrence McAfee, Michael Andersch, Mohammad Shoeybi, and Bryan Catanzaro. 2023. Reducing activation recomputation in large transformer models. In Proceedings of MLSys. 5, Curran, Red Hook, NY, USA. 341–353. https://proceedings.mlsys.org/paper_files/paper/2023/file/80083951326cf5b35e5100260d64ed81-Paper-mlsys2023.pdf
[43]
Shrawan Kumar, Bharti Chimdyalwar, and Ulka Shrotri. 2013. Precise Range Analysis on Large Industry Code. In Proceedings of ESEC/FSE. Association for Computing Machinery, New York, NY, USA. 675–678. isbn:9781450322379 https://doi.org/10.1145/2491411.2494569
[44]
Chris Lattner and Vikram Adve. 2004. LLVM: A Compilation Framework for Lifelong Program Analysis & Transformation. In Proceedings of CGO. IEEE, Piscataway, NJ, USA. 75–88. isbn:0-7695-2102-9 https://doi.org/10.1109/CGO.2004.1281665
[45]
Alan Leung, Manish Gupta, Yuvraj Agarwal, Rajesh Gupta, Ranjit Jhala, and Sorin Lerner. 2012. Verifying GPU kernels by test amplification. In Proceedings of PLDI. ACM, New York, NY, USA. 383–394. isbn:9781450312059 https://doi.org/10.1145/2254064.2254110
[46]
Guodong Li and Ganesh Gopalakrishnan. 2010. Scalable SMT-based verification of GPU kernel functions. In Proceedings of FSE. ACM, New York, NY, USA. 187–196. https://doi.org/10.1145/1882291.1882320
[47]
Guodong Li and Ganesh Gopalakrishnan. 2012. Parameterized Verification of GPU Kernel Programs. In Proceedings of IPDPSW. IEEE, Piscataway, NJ, USA. 2450–2459. https://doi.org/10.1109/IPDPSW.2012.302
[48]
Guodong Li, Peng Li, Geof Sawaya, Ganesh Gopalakrishnan, Indradeep Ghosh, and Sreeranga P. Rajan. 2012. GKLEE: Concolic Verification and Test Generation for GPUs. In Proceedings of PPoPP. 47, ACM, New York, NY, USA. 215–224. issn:0362-1340 https://doi.org/10.1145/2370036.2145844
[49]
Hongzhe Li, Taebeom Kim, Munkhbayar Bat-Erdene, and Heejo Lee. 2013. Software Vulnerability Detection Using Backward Trace Analysis and Symbolic Execution. In Proceedings of ARES. IEEE, Piscataway, NJ, USA. 446–454. https://doi.org/10.1109/ARES.2013.59
[50]
Pengcheng Li, Xiaoyu Hu, Dong Chen, Jacob Brock, Hao Luo, Eddy Z. Zhang, and Chen Ding. 2017. LD: Low-Overhead GPU Race Detection Without Access Monitoring. Transactions on Architecture and Code Optimization, 14, 1 (2017), Article 9, 25 pages. issn:1544-3566 https://doi.org/10.1145/3046678
[51]
Peng Li, Guodong Li, and Ganesh Gopalakrishnan. 2014. Practical Symbolic Race Checking of GPU Programs. In Proceedings of SC. IEEE, Piscataway, NJ, USA. 179–190. https://doi.org/10.1109/SC.2014.20
[52]
Dennis Liew, Tiago Cogumbreiro, and Julien Lange. 2022. Provable GPU Data-Races in Static Race Detection. In Proceedings of PLACES (EPTCS, Vol. 356). OPA, Waterloo, Australia. 36–45. https://doi.org/10.4204/EPTCS.356.4
[53]
Dennis Liew, Tiago Cogumbreiro, and Julien Lange. 2024. Sound and partially-complete static analysis of data-races in GPU programs (Artifact). https://doi.org/10.5281/zenodo.12666682
[54]
Stefan K. Muller and Jan Hoffmann. 2021. Modeling and Analyzing Evaluation Cost of CUDA Kernels. Proceedings of the ACM on Programming Languages, 5, POPL (2021), Article 25, 31 pages. https://doi.org/10.1145/3434306
[55]
Tukaram Muske and Uday P. Khedker. 2015. Efficient elimination of false positives using static analysis. In Proceedings of ISSRE. IEEE, Piscataway, NJ, USA. 270–280. https://doi.org/10.1109/ISSRE.2015.7381820
[56]
Tukaram Muske and Alexander Serebrenik. 2020. Techniques for Efficient Automated Elimination of False Positives. In Proceedings of SCAM. IEEE, Piscataway, NJ, USA. 259–263. https://doi.org/10.1109/SCAM51674.2020.00035
[57]
Marcus Nachtigall, Lisa Nguyen Quang Do, and Eric Bodden. 2019. Explaining Static Analysis — A Perspective. In Proceedings of ASEW. IEEE, Piscataway, NJ, USA. 29–32. https://doi.org/10.1109/ASEW.2019.00023
[58]
Giang Nguyen, Stefan Dlugolinsky, Martin Bobák, Viet Tran, Álvaro López García, Ignacio Heredia, Peter Malík, and Ladislav Hluchý. 2019. Machine Learning and Deep Learning frameworks and libraries for large-scale data mining: a survey. Artificial Intelligence Review, 52, 1 (2019), 77–124. issn:1573-7462 https://doi.org/10.1007/s10462-018-09679-z
[59]
Thu-Trang Nguyen, Toshiaki Aoki, Takashi Tomita, and Iori Yamada. 2019. Multiple Program Analysis Techniques Enable Precise Check for SEI CERT C Coding Standard. In Proceedings of APSEC. IEEE, Piscataway, NJ, USA. 70–77. https://doi.org/10.1109/APSEC48747.2019.00019
[60]
Yuanfeng Peng, Vinod Grover, and Joseph Devietti. 2018. CURD: A Dynamic CUDA Race Detector. In Proceedings of PLDI. ACM, New York, NY, USA. 390–403. isbn:978-1-4503-5698-5 https://doi.org/10.1145/3192366.3192368
[61]
Phillipe Pereira, Higo Albuquerque, Hendrio Marques, Isabela Silva, Celso Carvalho, Lucas Cordeiro, Vanessa Santos, and Ricardo Ferreira. 2016. Verifying CUDA Programs Using SMT-Based Context-Bounded Model Checking. In Proceedings of SAC. ACM, New York, NY, USA. 1648–1653. https://doi.org/10.1145/2851613.2851830
[62]
Corneliu Popeea and Wei-Ngan Chin. 2013. Dual analysis for proving safety and finding bugs. Science of Computer Programming, 78, 4 (2013), 390–411. issn:0167-6423 https://doi.org/10.1016/j.scico.2012.07.004
[63]
H. Post, C. Sinz, A. Kaiser, and T. Gorges. 2008. Reducing False Positives by Combining Abstract Interpretation and Bounded Model Checking. In Proceedings of ASE. IEEE, Piscataway, NJ, USA. 188–197. isbn:9781424421879 https://doi.org/10.1109/ASE.2008.29
[64]
Mukund Raghothaman, Sulekha Kulkarni, Kihong Heo, and Mayur Naik. 2018. User-guided program reasoning using Bayesian inference. In Proceedings of PLDI. ACM, New York, NY, USA. 722–735. isbn:9781450356985 https://doi.org/10.1145/3192366.3192417
[65]
Francesco Ranzato. 2013. Complete Abstractions Everywhere. In Proceedings of VMCAI. Springer, Berlin, Heidelberg. 15–26. isbn:9783642358722 https://doi.org/10.1007/978-3-642-35873-9_3
[66]
Xavier Rival. 2005. Understanding the Origin of Alarms in ASTRÉE. In Proceedings of SAS. Springer, Berlin, Heidelberg. 303–319. isbn:3540285849 https://doi.org/10.1007/11547662_21
[67]
Caitlin Sadowski, Edward Aftandilian, Alex Eagle, Liam Miller-Cushon, and Ciera Jaspan. 2018. Lessons from building static analysis tools at Google. Commun. ACM, 61, 4 (2018), 58–66. https://doi.org/10.1145/3188720
[68]
Lin Shi, Wen Liu, Heye Zhang, Yongming Xie, and Defeng Wang. 2012. A survey of GPU-based medical image computing techniques. Quantitative imaging in medicine and surgery, 2 (2012), 188–206. https://doi.org/10.3978/j.issn.2223-4292.2012.08.02
[69]
John E. Stone, David J. Hardy, Ivan S. Ufimtsev, and Klaus Schulten. 2010. GPU-accelerated molecular modeling coming of age. Journal of Molecular Graphics and Modelling, 29, 2 (2010), 116–125. issn:1093-3263 https://doi.org/10.1016/j.jmgm.2010.06.010
[70]
Manuel Valdiviezo, Cristina Cifuentes, and Padmanabhan Krishnan. 2014. A Method for Scalable and Precise Bug Finding Using Program Analysis and Model Checking. In Proceedings of APLAS. Springer, Cham. 196–215. isbn:978-3-319-12736-1 https://doi.org/10.1007/978-3-319-12736-1_11
[71]
Lei Wang, Qiang Zhang, and PengChao Zhao. 2008. Automated Detection of Code Vulnerabilities Based on Program Analysis and Model Checking. In Proceedings of SCAM. IEEE, Piscataway, NJ, USA. 165–173. https://doi.org/10.1109/SCAM.2008.24
[72]
Mingyuan Wu, Yicheng Ouyang, Husheng Zhou, Lingming Zhang, Cong Liu, and Yuqun Zhang. 2020. Simulee: Detecting CUDA Synchronization Bugs via Memory-Access Modeling. In Proceedings of ICSE. ACM, New York, NY, USA. 937–948. https://doi.org/10.1145/3377811.3380358
[73]
Junfeng Yang, Ang Cui, Sal Stolfo, and Simha Sethumadhavan. 2012. Concurrency Attacks. In Proceedings of HotPar. USENIX, Berkeley, CA, USA. 15–15. https://www.usenix.org/conference/hotpar12/concurrency-attacks
[74]
Tomofumi Yuki, Paul Feautrier, Sanjay Rajopadhye, and Vijay Saraswat. 2013. Array dataflow analysis for polyhedral X10 programs. In Proceedings of PPoPP. ACM, New York, NY, USA. 23–34. isbn:9781450319225 https://doi.org/10.1145/2442516.2442520
[75]
Bin Zhang, Chao Feng, Bo Wu, and Chaojing Tang. 2016. Detecting integer overflow in Windows binary executables based on symbolic execution. In Proceedings of SNPD. IEEE, Piscataway, NJ, USA. 385–390. https://doi.org/10.1109/SNPD.2016.7515929
[76]
Shixiong Zhao, Rui Gu, Haoran Qiu, Tsz On Li, Yuexuan Wang, Heming Cui, and Junfeng Yang. 2018. OWL: Understanding and Detecting Concurrency Attacks. In Proceedings of DSN. IEEE, Piscataway, NJ, USA. 219–230. issn:2158-3927 https://doi.org/10.1109/DSN.2018.00033
[77]
Mai Zheng, Vignesh T. Ravi, Feng Qin, and Gagan Agrawal. 2011. GRace: A Low-overhead Mechanism for Detecting Data Races in GPU Programs. In Proceedings of PPoPP. ACM, New York, NY, USA. 135–146. isbn:978-1-4503-0119-0 https://doi.org/10.1145/1941553.1941574
[78]
Mai Zheng, Vignesh T. Ravi, Feng Qin, and Gagan Agrawal. 2014. GMRace: Detecting Data Races in GPU Programs via a Low-Overhead Scheme. Transactions on Parallel and Distributed Systems, 25, 1 (2014), 104–115. https://doi.org/10.1109/TPDS.2013.44

Cited By

View all
  • (2024)HiRace: Accurate and Fast Data Race Checking for GPU ProgramsProceedings of the International Conference for High Performance Computing, Networking, Storage, and Analysis10.1109/SC41406.2024.00042(1-14)Online publication date: 17-Nov-2024

Recommendations

Comments

Information & Contributors

Information

Published In

cover image Proceedings of the ACM on Programming Languages
Proceedings of the ACM on Programming Languages  Volume 8, Issue OOPSLA2
October 2024
2691 pages
EISSN:2475-1421
DOI:10.1145/3554319
Issue’s Table of Contents
This work is licensed under a Creative Commons Attribution International 4.0 License.

Publisher

Association for Computing Machinery

New York, NY, United States

Publication History

Published: 08 October 2024
Published in PACMPL Volume 8, Issue OOPSLA2

Permissions

Request permissions for this article.

Check for updates

Badges

Author Tags

  1. GPU programming
  2. data-race detection
  3. static analysis
  4. true positives

Qualifiers

  • Research-article

Funding Sources

  • National Science Foundation

Contributors

Other Metrics

Bibliometrics & Citations

Bibliometrics

Article Metrics

  • Downloads (Last 12 months)330
  • Downloads (Last 6 weeks)75
Reflects downloads up to 23 Feb 2025

Other Metrics

Citations

Cited By

View all
  • (2024)HiRace: Accurate and Fast Data Race Checking for GPU ProgramsProceedings of the International Conference for High Performance Computing, Networking, Storage, and Analysis10.1109/SC41406.2024.00042(1-14)Online publication date: 17-Nov-2024

View Options

View options

PDF

View or Download as a PDF file.

PDF

eReader

View online with eReader.

eReader

Login options

Full Access

Figures

Tables

Media

Share

Share

Share this Publication link

Share on social media