Detecting harmful data races through parallel verification

Data races widely exist in concurrent programs and the harmful races have caused severe failures. To detect the harmful races, previous tools verify all the races, identifying the harmful ones. However, efficiency is affected when there are a large number of races needed to be verified. The multicore technology trend worsens this problem. Unlike previous work, to detect the harmful races, we try to improve the efficiency through parallel verification. We use imprecise race detection to find the races, including benign races and harmful races. The races are divided into many parts, and each part is sent to one machine for verification. On each machine, the races are verified dynamically, identifying the harmful races that would lead to program failures. To our knowledge, this is the first work that parallelizes race verification to improve the efficiency. We have experimented on a number of real-world concurrent programs and all the known harmful races in known benchmarks are detected. Additionally, our tool could scale well as the number of machines increases, and the speedup can also be increased linearly with the number of machines. Comparing with many previous tools, our work imposes lower runtime overhead.

[1]  Sorin Lerner,et al.  RELAY: static race detection on millions of lines of code , 2007, ESEC-FSE '07.

[2]  Harish Patil,et al.  Pin: building customized program analysis tools with dynamic instrumentation , 2005, PLDI '05.

[3]  Brandon Lucia,et al.  Atom-Aid: Detecting and Surviving Atomicity Violations , 2009, IEEE Micro.

[4]  Grigore Rosu,et al.  Maximal sound predictive race detection with control flow abstraction , 2014, PLDI.

[5]  Yuanyuan Zhou,et al.  Learning from mistakes: a comprehensive study on real world concurrency bug characteristics , 2008, ASPLOS.

[6]  Yuanyuan Zhou,et al.  AVIO: Detecting Atomicity Violations via Access-Interleaving Invariants , 2007, IEEE Micro.

[7]  Michael Hicks,et al.  LOCKSMITH: Practical static race detection for C , 2011, TOPL.

[8]  Dimitar Dimitrov,et al.  Commutativity race detection , 2014, PLDI.

[9]  Xu Zhou,et al.  RaceChecker: Efficient Identification of Harmful Data Races , 2015, 2015 23rd Euromicro International Conference on Parallel, Distributed, and Network-Based Processing.

[10]  Martin Rinard,et al.  Proceedings of the ACM international conference on Object oriented programming systems languages and applications , 2010 .

[11]  Shan Lu,et al.  Instrumentation and sampling strategies for cooperative concurrency bug isolation , 2010, OOPSLA.

[12]  Jens Palsberg,et al.  Race directed scheduling of concurrent programs , 2014, PPoPP '14.

[13]  Michael I. Jordan,et al.  Scalable statistical bug isolation , 2005, PLDI '05.

[14]  Xu Zhou,et al.  Exploiting parallelism in deterministic shared memory multiprocessing , 2012, J. Parallel Distributed Comput..

[15]  Wei Zhang,et al.  ConMem: detecting severe concurrency bugs through an effect-oriented approach , 2010, ASPLOS 2010.

[16]  Shan Lu,et al.  ConSeq: detecting concurrency bugs through sequential errors , 2011, ASPLOS XVI.

[17]  George Candea,et al.  RaceMob: crowdsourced data race detection , 2013, SOSP.

[18]  KasikciBaris,et al.  Data races vs. data race bugs , 2012 .

[19]  Kai Lu,et al.  PFinder: Efficiently detecting bugs in concurrent programs through parallelizing race verification , 2014, 2014 9th International Conference on Computer Engineering & Systems (ICCES).

[20]  Koushik Sen,et al.  Race directed random testing of concurrent programs , 2008, PLDI '08.

[21]  Michael D. Bond,et al.  PACER: proportional detection of data races , 2010, PLDI '10.

[22]  Kai Lu,et al.  Efficient deterministic multithreading without global barriers , 2014, PPoPP '14.

[23]  George Candea,et al.  Data races vs. data race bugs: telling the difference with portend , 2012, ASPLOS XVII.

[24]  Xu Zhou,et al.  Collaborative Technique for Concurrency Bug Detection , 2014, International Journal of Parallel Programming.

[25]  Michael Burrows,et al.  Eraser: a dynamic data race detector for multithreaded programs , 1997, TOCS.

[26]  Shan Lu,et al.  ConMem: detecting severe concurrency bugs through an effect-oriented approach , 2010, ASPLOS XV.

[27]  Xiao Ma,et al.  MUVI: automatically inferring multi-variable access correlations and detecting related semantic and concurrency bugs , 2007, SOSP.

[28]  Yuanyuan Zhou,et al.  CTrigger: exposing atomicity violation bugs from their hiding places , 2009, ASPLOS.

[29]  Dawson R. Engler,et al.  RacerX: effective, static detection of race conditions and deadlocks , 2003, SOSP '03.

[30]  Anoop Gupta,et al.  The SPLASH-2 programs: characterization and methodological considerations , 1995, ISCA.

[31]  Alexander Aiken,et al.  Effective static race detection for Java , 2006, PLDI '06.

[32]  Thomas Ball,et al.  Finding and Reproducing Heisenbugs in Concurrent Programs , 2008, OSDI.

[33]  Nicholas Sterling,et al.  WARLOCK - A Static Data Race Analysis Tool , 1993, USENIX Winter.

[34]  Jeff Huang,et al.  Persuasive prediction of concurrency access anomalies , 2011, ISSTA '11.

[35]  Satish Narayanasamy,et al.  Maple: a coverage-driven testing tool for multithreaded programs , 2012, OOPSLA '12.

[36]  Jong-Deok Choi,et al.  Hybrid dynamic data race detection , 2003, PPoPP '03.

[37]  Satish Narayanasamy,et al.  Automatically classifying benign and harmful data races using replay analysis , 2007, PLDI '07.

[38]  Shing-Chi Cheung,et al.  Detecting atomic-set serializability violations in multithreaded programs through active randomized testing , 2010, 2010 ACM/IEEE 32nd International Conference on Software Engineering.