research-article

RAProducer: efficiently diagnose and reproduce data race bugs for binaries via trace analysis

Authors:

Bodong ZhaoAuthors Info & Claims

ISSTA 2021: Proceedings of the 30th ACM SIGSOFT International Symposium on Software Testing and Analysis

Pages 593 - 606

https://doi.org/10.1145/3460319.3464831

Published: 11 July 2021 Publication History

Abstract

A growing number of bugs have been reported by vulnerability discovery solutions. Among them, some bugs are hard to diagnose or reproduce, including data race bugs caused by thread interleavings. Few solutions are able to well address this issue, due to the huge space of interleavings to explore. What’s worse, in security analysis scenarios, analysts usually have no access to the source code of target programs and have troubles in comprehending them.

In this paper, we propose a general solution RAProducer to efficiently diagnose and reproduce data race bugs, for both user-land binary programs and kernels without source code. The efficiency of RAProducer is achieved by analyzing the execution trace of the given PoC (proof-of-concept) sample to recognize race- and bug-related elements (including locks and shared variables), which greatly facilitate narrowing down the huge search space of data race spots and thread interleavings. We have implemented a prototype of RAProducer and evaluated it on 7 kernel and 10 user-land data race bugs. Evaluation results showed that, RAProducer is effective at reproducing all these bugs. More importantly, it enables us to diagnose 2 extra real world bugs which are left unconfirmed for a long time. It is also efficient as it reduces candidate data race spots of each bug to a small set, and narrows down the thread interleaving greatly.RAProducer is also more effective in reproducing real-world data race bugs than other state-of-the-art solutions.

References

[1]

[n.d.]. IDA Pro. https://www.hex-rays.com

[2]

[n.d.]. syzbot. https://syzkaller.appspot.com/upstream

[3]

Francesco A. Bianchi, Mauro Pezzè, and Valerio Terragni. 2017. Reproducing Concurrency Failures from Crash Stacks. In Proceedings of the 2017 11th Joint Meeting on Foundations of Software Engineering (ESEC/FSE 2017). Association for Computing Machinery, New York, NY, USA. 705–716. isbn:9781450351058 https://doi.org/10.1145/3106237.3106292

Digital Library

[4]

Michael D. Bond, Katherine E. Coons, and Kathryn S. McKinley. 2010. PACER: Proportional Detection of Data Races. 255–268. isbn:9781450300193 https://doi.org/10.1145/1806596.1806626

Digital Library

[5]

Arkady Bron, Eitan Farchi, Yonit Magid, Yarden Nir, and Shmuel Ur. 2005. Applications of Synchronization Coverage. In Proceedings of the Tenth ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming (PPoPP ’05). Association for Computing Machinery, New York, NY, USA. 206–212. isbn:1595930809 https://doi.org/10.1145/1065944.1065972

Digital Library

[6]

Sebastian Burckhardt, Pravesh Kothari, Madanlal Musuvathi, and Santosh Nagarakatte. 2010. A Randomized Scheduler with Probabilistic Guarantees of Finding Bugs. 167–178. isbn:9781605588391 https://doi.org/10.1145/1736020.1736040

Digital Library

[7]

Yan Cai and Zijiang Yang. 2016. Radius Aware Probabilistic Testing of Deadlocks with Guarantees. ASE 2016. Association for Computing Machinery, New York, NY, USA. 356–367. isbn:9781450338455 https://doi.org/10.1145/2970276.2970307

Digital Library

[8]

Yan Cai, Jian Zhang, Lingwei Cao, and Jian Liu. 2016. A Deployable Sampling Strategy for Data Race Detection. In Proceedings of the 2016 24th ACM SIGSOFT International Symposium on Foundations of Software Engineering (FSE 2016). Association for Computing Machinery, New York, NY, USA. 810–821. isbn:9781450342186 https://doi.org/10.1145/2950290.2950310

Digital Library

[9]

Yan Cai, Biyun Zhu, Ruijie Meng, Hao Yun, Liang He, Purui Su, and Bin Liang. 2019. Detecting Concurrency Memory Corruption Vulnerabilities. ESEC/FSE 2019. Association for Computing Machinery, New York, NY, USA. 706–717. isbn:9781450355728 https://doi.org/10.1145/3338906.3338927

Digital Library

[10]

Yufei Chen and Haibo Chen. 2013. Scalable Deterministic Replay in a Parallel Full-System Emulator. SIGPLAN Not., 48, 8 (2013), Feb., 207–218. issn:0362-1340 https://doi.org/10.1145/2517327.2442537

Digital Library

[11]

Brendan Dolan-Gavitt, Josh Hodosh, Patrick Hulin, Tim Leek, and Ryan Whelan. 2015. Repeatable Reverse Engineering with PANDA. In Proceedings of the 5th Program Protection and Reverse Engineering Workshop (PPREW-5). Association for Computing Machinery, New York, NY, USA. Article 4, 11 pages. isbn:9781450336420 https://doi.org/10.1145/2843859.2843867

Digital Library

[12]

Tayfun Elmas, Shaz Qadeer, and Serdar Tasiran. 2007. Goldilocks: A Race and Transaction-Aware Java Runtime. 245–255. isbn:9781595936332 https://doi.org/10.1145/1250734.1250762

Digital Library

[13]

John Erickson, Madanlal Musuvathi, Sebastian Burckhardt, and Kirk Olynyk. 2010. Effective Data-Race Detection for the Kernel. In Proceedings of the 9th USENIX Conference on Operating Systems Design and Implementation (OSDI’10). USENIX Association, USA. 151–162.

Digital Library

[14]

Mahdi Eslamimehr and Jens Palsberg. 2014. Race Directed Scheduling of Concurrent Programs. 301–314. isbn:9781450326568 https://doi.org/10.1145/2555243.2555263

Digital Library

[15]

Cormac Flanagan and Stephen N. Freund. 2009. FastTrack: Efficient and Precise Dynamic Race Detection. 121–133. isbn:9781605583921 https://doi.org/10.1145/1542476.1542490

Digital Library

[16]

Pedro Fonseca, Rodrigo Rodrigues, and Björn B. Brandenburg. 2014. SKI: Exposing Kernel Concurrency Bugs through Systematic Schedule Exploration. In Proceedings of the 11th USENIX Conference on Operating Systems Design and Implementation (OSDI’14). USENIX Association, USA. 415–431. isbn:9781931971164

[17]

Jeff Huang. 2018. UFO: Predictive Concurrency Use-after-Free Detection. In Proceedings of the 40th International Conference on Software Engineering (ICSE ’18). Association for Computing Machinery, New York, NY, USA. 609–619. isbn:9781450356381 https://doi.org/10.1145/3180155.3180225

Digital Library

[18]

Jeff Huang, Patrick O’Neil Meredith, and Grigore Rosu. 2014. Maximal Sound Predictive Race Detection with Control Flow Abstraction. In Proceedings of the 35th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI ’14). Association for Computing Machinery, New York, NY, USA. 337–348. isbn:9781450327848 https://doi.org/10.1145/2594291.2594315

Digital Library

[19]

Jeff Huang and Charles Zhang. 2012. LEAN: Simplifying Concurrency Bug Reproduction via Replay-Supported Execution Reduction. In Proceedings of the ACM International Conference on Object Oriented Programming Systems Languages and Applications (OOPSLA ’12). Association for Computing Machinery, New York, NY, USA. 451–466. isbn:9781450315616 https://doi.org/10.1145/2384616.2384649

Digital Library

[20]

Jeff Huang, Charles Zhang, and Julian Dolby. 2013. CLAP: Recording Local Executions to Reproduce Concurrency Failures. SIGPLAN Not., 48, 6 (2013), June, 141–152. issn:0362-1340 https://doi.org/10.1145/2499370.2462167

Digital Library

[21]

Ali Jannesari and Walter F. Tichy. 2010. Identifying ad-hoc synchronization for enhanced race detection. In 2010 IEEE International Symposium on Parallel Distributed Processing (IPDPS). 1–10. https://doi.org/10.1109/IPDPS.2010.5470343

[22]

Dae R. Jeong, Kyungtae Kim, Basavesh Shivakumar, Byoungyoung Lee, and Insik Shin. 2019. Razzer: Finding Kernel Race Bugs through Fuzzing. In 2019 IEEE Symposium on Security and Privacy (SP). 754–768. https://doi.org/10.1109/SP.2019.00017

[23]

Baris Kasikci, Weidong Cui, Xinyang Ge, and Ben Niu. 2017. Lazy Diagnosis of In-Production Concurrency Bugs. In Proceedings of the 26th Symposium on Operating Systems Principles (SOSP ’17). Association for Computing Machinery, New York, NY, USA. 582–598. isbn:9781450350853 https://doi.org/10.1145/3132747.3132767

Digital Library

[24]

Baris Kasikci, Benjamin Schubert, Cristiano Pereira, Gilles Pokam, and George Candea. 2015. Failure Sketching: A Technique for Automated Root Cause Diagnosis of in-Production Failures. In Proceedings of the 25th Symposium on Operating Systems Principles. Association for Computing Machinery, New York, NY, USA. 344–360. isbn:9781450338349 https://doi.org/10.1145/2815400.2815412

Digital Library

[25]

Bohuslav Křena, Zdeněk Letko, and Tomáš Vojnar. 2011. Coverage Metrics for Saturation-Based and Search-Based Testing of Concurrent Software. In Proceedings of the Second International Conference on Runtime Verification (RV’11). Springer-Verlag, Berlin, Heidelberg. 177–192. isbn:9783642298592 https://doi.org/10.1007/978-3-642-29860-8_14

Digital Library

[26]

Dongyoon Lee, Mahmoud Said, Satish Narayanasamy, and Zijiang Yang. 2011. Offline symbolic analysis to infer total store order. In 2011 IEEE 17th International Symposium on High Performance Computer Architecture. 357–358. https://doi.org/10.1109/HPCA.2011.5749743

[27]

Dongyoon Lee, Mahmoud Said, Satish Narayanasamy, Zijiang Yang, and Cristiano Pereira. 2009. Offline Symbolic Analysis for Multi-Processor Execution Replay. In Proceedings of the 42nd Annual IEEE/ACM International Symposium on Microarchitecture (MICRO 42). Association for Computing Machinery, New York, NY, USA. 564–575. isbn:9781605587981 https://doi.org/10.1145/1669112.1669182

Digital Library

[28]

Guangpu Li, Shan Lu, Madanlal Musuvathi, Suman Nath, and Rohan Padhye. 2019. Efficient Scalable Thread-Safety-Violation Detection: Finding Thousands of Concurrency Bugs during Testing. In Proceedings of the 27th ACM Symposium on Operating Systems Principles (SOSP ’19). Association for Computing Machinery, New York, NY, USA. 162–180. isbn:9781450368735 https://doi.org/10.1145/3341301.3359638

Digital Library

[29]

Christopher Lidbury and Alastair F. Donaldson. 2019. Sparse Record and Replay with Controlled Scheduling. In Proceedings of the 40th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI 2019). Association for Computing Machinery, New York, NY, USA. 576–593. isbn:9781450367127 https://doi.org/10.1145/3314221.3314635

Digital Library

[30]

Shan Lu, Soyeon Park, Eunsoo Seo, and Yuanyuan Zhou. 2008. Learning from mistakes: A comprehensive study on real world concurrency bug characteristics. SIGARCH Computer Architecture News, 36, 329–339. https://doi.org/10.1145/1346281.1346323

Digital Library

[31]

Nuno Machado, Brandon Lucia, and Luís Rodrigues. 2015. Concurrency Debugging with Differential Schedule Projections. SIGPLAN Not., 50, 6 (2015), June, 586–595. issn:0362-1340 https://doi.org/10.1145/2813885.2737973

Digital Library

[32]

Nuno Machado, Brandon Lucia, and Luís Rodrigues. 2016. Production-Guided Concurrency Debugging. In Proceedings of the 21st ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming (PPoPP ’16). Association for Computing Machinery, New York, NY, USA. Article 29, 12 pages. isbn:9781450340922 https://doi.org/10.1145/2851141.2851149

Digital Library

[33]

Nuno Machado, Paolo Romano, and Luís Rodrigues. 2018. CoopREP: Cooperative record and replay of concurrency bugs. Software Testing, Verification and Reliability, 28, 1 (2018), e1645.

[34]

Daniel Marino, Madanlal Musuvathi, and Satish Narayanasamy. 2009. LiteRace: Effective Sampling for Lightweight Data-Race Detection. SIGPLAN Not., 44, 6, 134–143. issn:0362-1340 https://doi.org/10.1145/1543135.1542491

Digital Library

[35]

Ruijie Meng, Biyun Zhu, Hao Yun, Haicheng Li, Yan Cai, and Zijiang Yang. 2019. CONVUL: An Effective Tool for Detecting Concurrency Vulnerabilities. In Proceedings of the 34th IEEE/ACM International Conference on Automated Software Engineering (ASE ’19). IEEE Press, 1154–1157. isbn:9781728125084 https://doi.org/10.1109/ASE.2019.00125

Digital Library

[36]

Pablo Montesinos, Matthew Hicks, Samuel T. King, and Josep Torrellas. 2009. Capo: A Software-Hardware Interface for Practical Deterministic Multiprocessor Replay. In Proceedings of the 14th International Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS XIV). Association for Computing Machinery, New York, NY, USA. 73–84. isbn:9781605584065 https://doi.org/10.1145/1508244.1508254

Digital Library

[37]

Madanlal Musuvathi, Shaz Qadeer, Thomas Ball, Gerard Basler, Piramanayagam Arumuga Nainar, and Iulian Neamtiu. 2008. Finding and Reproducing Heisenbugs in Concurrent Programs. In Proceedings of the 8th USENIX Conference on Operating Systems Design and Implementation (OSDI’08). USENIX Association, USA. 267–280.

Digital Library

[38]

Robert H. B. Netzer and Barton P. Miller. 1992. What Are Race Conditions? Some Issues and Formalizations. ACM Lett. Program. Lang. Syst., 1, 1 (1992), March, 74–88. issn:1057-4514 https://doi.org/10.1145/130616.130623

Digital Library

[39]

Chang-Seo Park, Koushik Sen, Paul Hargrove, and Costin Iancu. 2011. Efficient Data Race Detection for Distributed Memory Parallel Programs. In Proceedings of 2011 International Conference for High Performance Computing, Networking, Storage and Analysis (SC ’11). Association for Computing Machinery, New York, NY, USA. Article 51, 12 pages. isbn:9781450307710 https://doi.org/10.1145/2063384.2063452

Digital Library

[40]

Soyeon Park, Shan Lu, and Yuanyuan Zhou. 2009. CTrigger: Exposing Atomicity Violation Bugs from Their Hiding Places. In Proceedings of the 14th International Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS XIV). Association for Computing Machinery, New York, NY, USA. 25–36. isbn:9781605584065 https://doi.org/10.1145/1508244.1508249

Digital Library

[41]

Soyeon Park, Yuanyuan Zhou, Weiwei Xiong, Zuoning Yin, Rini Kaushik, Kyu H. Lee, and Shan Lu. 2009. PRES: Probabilistic Replay with Execution Sketching on Multiprocessors. In Proceedings of the ACM SIGOPS 22nd Symposium on Operating Systems Principles (SOSP ’09). Association for Computing Machinery, New York, NY, USA. 177–192. isbn:9781605587523 https://doi.org/10.1145/1629575.1629593

Digital Library

[42]

Gilles Pokam, Klaus Danne, Cristiano Pereira, Rolf Kassa, Tim Kranich, Shiliang Hu, Justin Gottschlich, Nima Honarmand, Nathan Dautenhahn, Samuel T. King, and Josep Torrellas. 2013. QuickRec: Prototyping an Intel Architecture Extension for Record and Replay of Multithreaded Programs. In Proceedings of the 40th Annual International Symposium on Computer Architecture (ISCA ’13). Association for Computing Machinery, New York, NY, USA. 643–654. isbn:9781450320795 https://doi.org/10.1145/2485922.2485977

Digital Library

[43]

Gilles Pokam, Cristiano Pereira, Shiliang Hu, Ali-Reza Adl-Tabatabai, Justin Gottschlich, Jungwoo Ha, and Youfeng Wu. 2011. CoreRacer: A Practical Memory Race Recorder for Multicore X86 TSO Processors. In Proceedings of the 44th Annual IEEE/ACM International Symposium on Microarchitecture (MICRO-44). Association for Computing Machinery, New York, NY, USA. 216–225. isbn:9781450310536 https://doi.org/10.1145/2155620.2155646

Digital Library

[44]

Sri Varun Poluri and Murali Krishna Ramanathan. 2015. Deterministic dynamic race detection across program versions. In 2015 IEEE International Conference on Software Maintenance and Evolution, ICSME 2015, Bremen, Germany, September 29 - October 1, 2015, Rainer Koschke, Jens Krinke, and Martin P. Robillard (Eds.). IEEE Computer Society, 181–190. https://doi.org/10.1109/ICSM.2015.7332464

Digital Library

[45]

Shiru Ren, Le Tan, Chunqi Li, Zhen Xiao, and Weijia Song. 2016. Samsara: Efficient Deterministic Replay in Multiprocessor Environments with Hardware Virtualization Extensions. In Proceedings of the 2016 USENIX Conference on Usenix Annual Technical Conference (USENIX ATC ’16). USENIX Association, USA. 551–564. isbn:9781931971300 https://doi.org/10.1145/2797022.2797028

Digital Library

[46]

Stefan Savage, Michael Burrows, Greg Nelson, Patrick Sobalvarro, and Thomas Anderson. 1997. Eraser: A Dynamic Data Race Detector for Multithreaded Programs. ACM Trans. Comput. Syst., 15, 4 (1997), Nov., 391–411. issn:0734-2071 https://doi.org/10.1145/265924.265927

Digital Library

[47]

Ohad Shacham, Mooly Sagiv, and Assaf Schuster. 2005. Scaling Model Checking of Dataraces Using Dynamic Information. 107–118. isbn:1595930809 https://doi.org/10.1145/1065944.1065958

Digital Library

[48]

Francesco Sorrentino, Azadeh Farzan, and P. Madhusudan. 2010. PENELOPE: Weaving Threads to Expose Atomicity Violations. FSE ’10. Association for Computing Machinery, New York, NY, USA. 37–46. isbn:9781605587912 https://doi.org/10.1145/1882291.1882300

Digital Library

[49]

Chen Tian, Vijay Nagarajan, Rajiv Gupta, and Sriraman Tallam. 2008. Dynamic recognition of synchronization operations for improved data race detection. In Proceedings of the 2008 international symposium on Software testing and analysis. 143–154. https://doi.org/10.1145/1390630.1390649

Digital Library

[50]

Kaushik Veeraraghavan, Dongyoon Lee, Benjamin Wester, Jessica Ouyang, Peter M. Chen, Jason Flinn, and Satish Narayanasamy. 2012. DoublePlay: Parallelizing Sequential Logging and Replay. ACM Trans. Comput. Syst., 30, 1 (2012), Article 3, Feb., 24 pages. issn:0734-2071 https://doi.org/10.1145/2110356.2110359

Digital Library

[51]

Christoph von Praun and Thomas R. Gross. 2001. Object Race Detection. 70–82. isbn:1581133359 https://doi.org/10.1145/504282.504288

Digital Library

[52]

Dmitry Vyukov. 2015. Syzkaller. https://github.com/google/syzkaller

[53]

Chao Wang, Mahmoud Said, and Aarti Gupta. 2011. Coverage Guided Systematic Concurrency Testing. In Proceedings of the 33rd International Conference on Software Engineering (ICSE ’11). Association for Computing Machinery, New York, NY, USA. 221–230. isbn:9781450304450 https://doi.org/10.1145/1985793.1985824

Digital Library

[54]

Tao Wang, Xiao Yu, Zhengyi Qiu, Guoliang Jin, and Frank Mueller. [n.d.]. BARRIERFINDER: Recognizing Ad Hoc Barriers. In 2019 IEEE International Conference on Software Maintenance and Evolution (ICSME). 323–327.

[55]

James R. Wilcox, Parker Finch, Cormac Flanagan, and Stephen N. Freund. 2015. Array Shadow State Compression for Precise Dynamic Race Detection. ASE ’15. IEEE Press, 155–165. isbn:9781509000241 https://doi.org/10.1109/ASE.2015.19

Digital Library

[56]

Weiwei Xiong, Soyeon Park, Jiaqi Zhang, Yuanyuan Zhou, and Zhiqiang Ma. 2010. Ad Hoc Synchronization Considered Harmful. In Proceedings of the 9th USENIX Conference on Operating Systems Design and Implementation (OSDI’10). USENIX Association, USA. 163–176.

Digital Library

[57]

Wei You, Peiyuan Zong, Kai Chen, XiaoFeng Wang, Xiaojing Liao, Pan Bian, and Bin Liang. 2017. SemFuzz: Semantics-Based Automatic Generation of Proof-of-Concept Exploits. In Proceedings of the 2017 ACM SIGSAC Conference on Computer and Communications Security (CCS ’17). Association for Computing Machinery, New York, NY, USA. 2139–2154. isbn:9781450349468 https://doi.org/10.1145/3133956.3134085

Digital Library

[58]

Jie Yu, Satish Narayanasamy, Cristiano Pereira, and Gilles Pokam. 2012. Maple: A Coverage-Driven Testing Tool for Multithreaded Programs. In Proceedings of the ACM International Conference on Object Oriented Programming Systems Languages and Applications (OOPSLA ’12). Association for Computing Machinery, New York, NY, USA. 485–502. isbn:9781450315616 https://doi.org/10.1145/2384616.2384651

Digital Library

[59]

Yuan Yu, Tom Rodeheffer, and Wei Chen. 2005. RaceTrack: Efficient Detection of Data Race Conditions via Adaptive Tracking. In Proceedings of the Twentieth ACM Symposium on Operating Systems Principles (SOSP ’05). Association for Computing Machinery, New York, NY, USA. 221–234. isbn:1595930795 https://doi.org/10.1145/1095810.1095832

Digital Library

[60]

Xiang Yuan, Zhenjiang Wang, Chenggang Wu, Pen-Chung Yew, Wenwen Wang, Jianjun Li, and Di Xu. 2013. Synchronization Identification through On-the-Fly Test. In Proceedings of the 19th International Conference on Parallel Processing (Euro-Par’13). Springer-Verlag, Berlin, Heidelberg. 4–15. isbn:9783642400469 https://doi.org/10.1007/978-3-642-40047-6_3

Digital Library

[61]

Xiang Yuan, Chenggang Wu, Zhenjiang Wang, Jianjun Li, Pen-Chung Yew, Jeff Huang, Xiaobing Feng, Yanyan Lan, Yunji Chen, and Yong Guan. 2015. ReCBuLC: Reproducing Concurrency Bugs Using Local Clocks. In Proceedings of the 37th International Conference on Software Engineering - Volume 1 (ICSE ’15). IEEE Press, 824–834. isbn:9781479919345 https://doi.org/10.1109/ICSE.2015.94

[62]

Wei Zhang, Junghee Lim, Ramya Olichandran, Joel Scherpelz, Guoliang Jin, Shan Lu, and Thomas Reps. 2011. ConSeq: Detecting Concurrency Bugs through Sequential Errors. 251–264. isbn:9781450302661 https://doi.org/10.1145/1950365.1950395

Digital Library

Cited By

Dai YWu PCui SMa L(2024)Intrathread Method Orders Based Adaptive Testing of Concurrent ObjectsTheoretical Aspects of Software Engineering10.1007/978-3-031-64626-3_6(91-108)Online publication date: 14-Jul-2024
https://doi.org/10.1007/978-3-031-64626-3_6
Guo YLiang ZZhu SWang JYang ZShen WZhang JCai Y(2023)Sound Predictive Fuzzing for Multi-threaded Programs2023 IEEE 47th Annual Computers, Software, and Applications Conference (COMPSAC)10.1109/COMPSAC57700.2023.00110(810-819)Online publication date: Jun-2023
https://doi.org/10.1109/COMPSAC57700.2023.00110
Wen CHe MWu BXu ZQin SDwyer MDamian DZeller A(2022)Controlled concurrency testing via periodical schedulingProceedings of the 44th International Conference on Software Engineering10.1145/3510003.3510178(474-486)Online publication date: 21-May-2022
https://dl.acm.org/doi/10.1145/3510003.3510178

Index Terms

RAProducer: efficiently diagnose and reproduce data race bugs for binaries via trace analysis
1. Security and privacy
  1. Software and application security

Recommendations

Automated data race bugs addition
EuroSec '20: Proceedings of the 13th European workshop on Systems Security

A challenge faced by concurrency bug detection techniques is the lack of ground-truth corpora, i.e., a lot of true concurrency bugs, making it difficult to evaluate and verify these technologies and tools, e.g., to precisely measure their false negative ...
Data race avoidance and replay scheme for developing and debugging parallel programs on distributed shared memory systems

Distributed shared memory (DSM) allows parallel programs to run on distributed computers by simulating a global virtual shared memory, but data racing bugs may easily occur when the threads of a multi-threaded process concurrently access the physically ...
Data races vs. data race bugs: telling the difference with portend
ASPLOS '12

Even though most data races are harmless, the harmful ones are at the heart of some of the worst concurrency bugs. Alas, spotting just the harmful data races in programs is like finding a needle in a haystack: 76%-90% of the true data races reported by ...

Comments

Information & Contributors

Information

Published In

cover image ACM Conferences

ISSTA 2021: Proceedings of the 30th ACM SIGSOFT International Symposium on Software Testing and Analysis

July 2021

685 pages

ISBN:9781450384599

DOI:10.1145/3460319

General Chair:
Cristian Cadar
Imperial College London, UK
,
Program Chair:
Xiangyu Zhang
Purdue University, USA

Copyright © 2021 ACM.

Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. Copyrights for components of this work owned by others than the author(s) must be honored. Abstracting with credit is permitted. To copy otherwise, or republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee. Request permissions from [email protected].

Sponsors

SIGSOFT: ACM Special Interest Group on Software Engineering

Publisher

Association for Computing Machinery

New York, NY, United States

Publication History

Published: 11 July 2021

Permissions

Request permissions for this article.

Request Permissions

Check for updates

Author Tags

Qualifiers

Research-article

Funding Sources

National Natural Science Foundation of China
Key Research Program of Frontier Sciences, CAS
BNRist Network and Software Security Research Program

Conference

ISSTA '21

Sponsor:

SIGSOFT

ISSTA '21: 30th ACM SIGSOFT International Symposium on Software Testing and Analysis

July 11 - 17, 2021

Virtual, Denmark

Acceptance Rates

Overall Acceptance Rate 58 of 213 submissions, 27%

Upcoming Conference

ISSTA '24

Sponsor:
sigsoft

33rd ACM SIGSOFT International Symposium on Software Testing and Analysis

September 16 - 20, 2024

Vienna , Austria

Contributors

Other Metrics

View Article Metrics

Bibliometrics & Citations

Bibliometrics

Article Metrics

3
Total Citations
View Citations
429
Total Downloads

Downloads (Last 12 months)76
Downloads (Last 6 weeks)4

Reflects downloads up to 10 Aug 2024

Other Metrics

View Author Metrics

Citations

Cited By

Dai YWu PCui SMa L(2024)Intrathread Method Orders Based Adaptive Testing of Concurrent ObjectsTheoretical Aspects of Software Engineering10.1007/978-3-031-64626-3_6(91-108)Online publication date: 14-Jul-2024
https://doi.org/10.1007/978-3-031-64626-3_6
Guo YLiang ZZhu SWang JYang ZShen WZhang JCai Y(2023)Sound Predictive Fuzzing for Multi-threaded Programs2023 IEEE 47th Annual Computers, Software, and Applications Conference (COMPSAC)10.1109/COMPSAC57700.2023.00110(810-819)Online publication date: Jun-2023
https://doi.org/10.1109/COMPSAC57700.2023.00110
Wen CHe MWu BXu ZQin SDwyer MDamian DZeller A(2022)Controlled concurrency testing via periodical schedulingProceedings of the 44th International Conference on Software Engineering10.1145/3510003.3510178(474-486)Online publication date: 21-May-2022
https://dl.acm.org/doi/10.1145/3510003.3510178

View Options

Get Access

Login options

Check if you have access through your login credentials or your institution to get full access on this article.

Full Access

Get this Publication

View options

PDF

View or Download as a PDF file.

eReader

View online with eReader.

Media

Figures

Other

Tables

View Table of Contents