Papers
Topics
Authors
Recent
Gemini 2.5 Flash
Gemini 2.5 Flash
156 tokens/sec
GPT-4o
7 tokens/sec
Gemini 2.5 Pro Pro
45 tokens/sec
o3 Pro
4 tokens/sec
GPT-4.1 Pro
38 tokens/sec
DeepSeek R1 via Azure Pro
28 tokens/sec
2000 character limit reached

Predictive Monitoring against Pattern Regular Languages (2310.14611v2)

Published 23 Oct 2023 in cs.PL

Abstract: In this paper, we focus on the problem of dynamically analysing concurrent software against high-level temporal specifications. Existing techniques for runtime monitoring against such specifications are primarily designed for sequential software and remain inadequate in the presence of concurrency -- violations may be observed only in intricate thread interleavings, requiring many re-runs of the underlying software. Towards this, we study the problem of predictive runtime monitoring, inspired by the analogous problem of predictive data race detection studied extensively recently. The predictive runtime monitoring question asks, given an execution $\sigma$, if it can be soundly reordered to expose violations of a specification. In this paper, we focus on specifications that are given in regular languages. Our notion of reorderings is trace equivalence, where an execution is considered a reordering of another if it can be obtained from the latter by successively commuting adjacent independent actions. We first show that the problem of predictive admits a super-linear lower bound of $O(n\alpha)$, where $n$ is the number of events in the execution, and $\alpha$ is a parameter describing the degree of commutativity. As a result, predictive runtime monitoring even in this setting is unlikely to be efficiently solvable. Towards this, we identify a sub-class of regular languages, called pattern languages (and their extension generalized pattern languages). Pattern languages can naturally express specific ordering of some number of (labelled) events, and have been inspired by popular empirical hypotheses, the `small bug depth' hypothesis. More importantly, we show that for pattern (and generalized pattern) languages, the predictive monitoring problem can be solved using a constant-space streaming linear-time algorithm.

Definition Search Book Streamline Icon: https://streamlinehq.com
References (103)
  1. 2023. AntLRWorks. https://github.com/antlr/antlrworks. [Online; accessed 24-October-2023].
  2. 2023. exp4j. https://github.com/fasseg/exp4j. [Online; accessed 24-October-2023].
  3. 2023. JFreeChart. https://github.com/jfree/jfreechart. [Online; accessed 24-October-2023].
  4. 2023. Logstash Logback Encoder. https://github.com/logfellow/logstash-logback-encoder. [Online; accessed 24-October-2023].
  5. 2023. ZeroMQ log4j appender. https://github.com/lusis/zmq-appender. [Online; accessed 24-October-2023].
  6. Optimal dynamic partial order reduction. In The 41st Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL ’14, San Diego, CA, USA, January 20-21, 2014, Suresh Jagannathan and Peter Sewell (Eds.). ACM, 373–384. https://doi.org/10.1145/2535838.2535845
  7. Verification of Programs under the Release-Acquire Semantics. In Proceedings of the 40th ACM SIGPLAN Conference on Programming Language Design and Implementation (Phoenix, AZ, USA) (PLDI 2019). Association for Computing Machinery, New York, NY, USA, 1117–1132. https://doi.org/10.1145/3314221.3314649
  8. Nekara: Generalised Concurrency Testing. In 2021 36th IEEE/ACM International Conference on Automated Software Engineering (ASE). 679–691. https://doi.org/10.1109/ASE51524.2021.9678838
  9. Rakesh Agrawal and Ramakrishnan Srikant. 1995. Mining Sequential Patterns. In Proceedings of the Eleventh International Conference on Data Engineering, March 6-10, 1995, Taipei, Taiwan, Philip S. Yu and Arbee L. P. Chen (Eds.). IEEE Computer Society, 3–14. https://doi.org/10.1109/ICDE.1995.380415
  10. A Temporal Logic of Nested Calls and Returns. In Tools and Algorithms for the Construction and Analysis of Systems, 10th International Conference, TACAS 2004, Held as Part of the Joint European Conferences on Theory and Practice of Software, ETAPS 2004, Barcelona, Spain, March 29 - April 2, 2004, Proceedings (Lecture Notes in Computer Science, Vol. 2988), Kurt Jensen and Andreas Podelski (Eds.). Springer, 467–481. https://doi.org/10.1007/978-3-540-24730-2_35
  11. Zhendong Ang and Umang Mathur. 2023. Predictive Monitoring against Pattern Regular Languages. https://doi.org/10.5281/zenodo.8424626 Artifact.
  12. High-level data races. Softw. Test. Verification Reliab. 13, 4 (2003), 207–227. https://doi.org/10.1002/STVR.281
  13. Saddek Bensalem and Klaus Havelund. 2005. Dynamic Deadlock Analysis of Multi-threaded Programs. In Hardware and Software Verification and Testing, First International Haifa Verification Conference, Haifa, Israel, November 13-16, 2005, Revised Selected Papers (Lecture Notes in Computer Science, Vol. 3875), Shmuel Ur, Eyal Bin, and Yaron Wolfsthal (Eds.). Springer, 208–223. https://doi.org/10.1007/11678779_15
  14. Membership problems for regular and context-free trace languages. Information and Computation 82, 2 (1989), 135–150. https://doi.org/10.1016/0890-5401(89)90051-5
  15. DoubleChecker: efficient sound and precise atomicity checking. In ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI ’14, Edinburgh, United Kingdom - June 09 - 11, 2014, Michael F. P. O’Boyle and Keshav Pingali (Eds.). ACM, 28–39. https://doi.org/10.1145/2594291.2594323
  16. The DaCapo benchmarks: java benchmarking development and analysis. In Proceedings of the 21th Annual ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications, OOPSLA 2006, October 22-26, 2006, Portland, Oregon, USA, Peri L. Tarr and William R. Cook (Eds.). ACM, 169–190. https://doi.org/10.1145/1167473.1167488
  17. RacerD: Compositional Static Race Detection. Proc. ACM Program. Lang. 2, OOPSLA, Article 144 (oct 2018), 28 pages. https://doi.org/10.1145/3276514
  18. Permutation Rewriting and Algorithmic Verification. In 16th Annual IEEE Symposium on Logic in Computer Science, Boston, Massachusetts, USA, June 16-19, 2001, Proceedings. IEEE Computer Society, 399–408. https://doi.org/10.1109/LICS.2001.932515
  19. Ownership types for safe programming: preventing data races and deadlocks. In Proceedings of the 2002 ACM SIGPLAN Conference on Object-Oriented Programming Systems, Languages and Applications, OOPSLA 2002, Seattle, Washington, USA, November 4-8, 2002, Mamdouh Ibrahim and Satoshi Matsuoka (Eds.). ACM, 211–230. https://doi.org/10.1145/582419.582440
  20. A Randomized Scheduler with Probabilistic Guarantees of Finding Bugs. In Proceedings of the Fifteenth International Conference on Architectural Support for Programming Languages and Operating Systems (Pittsburgh, Pennsylvania, USA) (ASPLOS XV). Association for Computing Machinery, New York, NY, USA, 167–178. https://doi.org/10.1145/1736020.1736040
  21. Low-overhead deadlock prediction. In ICSE ’20: 42nd International Conference on Software Engineering, Seoul, South Korea, 27 June - 19 July, 2020, Gregg Rothermel and Doo-Hwan Bae (Eds.). ACM, 1298–1309. https://doi.org/10.1145/3377811.3380367
  22. Sound and efficient concurrency bug prediction. In ESEC/FSE ’21: 29th ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering, Athens, Greece, August 23-28, 2021, Diomidis Spinellis, Georgios Gousios, Marsha Chechik, and Massimiliano Di Penta (Eds.). ACM, 255–267. https://doi.org/10.1145/3468264.3468549
  23. The Complexity of Satisfiability of Small Depth Circuits. In Parameterized and Exact Computation: 4th International Workshop, IWPEC 2009, Copenhagen, Denmark, September 10-11, 2009, Revised Selected Papers. Springer-Verlag, Berlin, Heidelberg, 75–85. https://doi.org/10.1007/978-3-642-11269-0_6
  24. Feng Chen and Grigore Rosu. 2007. Parametric and Sliced Causality. In Computer Aided Verification, 19th International Conference, CAV 2007, Berlin, Germany, July 3-7, 2007, Proceedings (Lecture Notes in Computer Science, Vol. 4590), Werner Damm and Holger Hermanns (Eds.). Springer, 240–253. https://doi.org/10.1007/978-3-540-73368-3_27
  25. jPredictor: a predictive runtime analysis tool for java. In 30th International Conference on Software Engineering (ICSE 2008), Leipzig, Germany, May 10-18, 2008, Wilhelm Schäfer, Matthew B. Dwyer, and Volker Gruhn (Eds.). ACM, 221–230. https://doi.org/10.1145/1368088.1368119
  26. Hitting Families of Schedules for Asynchronous Programs. In Computer Aided Verification - 28th International Conference, CAV 2016, Toronto, ON, Canada, July 17-23, 2016, Proceedings, Part II (Lecture Notes in Computer Science, Vol. 9780), Swarat Chaudhuri and Azadeh Farzan (Eds.). Springer, 157–176. https://doi.org/10.1007/978-3-319-41540-6_9
  27. Automatic Verification of Finite-State Concurrent Systems Using Temporal Logic Specifications. ACM Trans. Program. Lang. Syst. 8, 2 (1986), 244–263. https://doi.org/10.1145/5397.5399
  28. Delay-Bounded Scheduling. In Proceedings of the 38th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (Austin, Texas, USA) (POPL ’11). Association for Computing Machinery, New York, NY, USA, 411–422. https://doi.org/10.1145/1926385.1926432
  29. Dawson Engler and Ken Ashcraft. 2003. RacerX: Effective, Static Detection of Race Conditions and Deadlocks. In Proceedings of the Nineteenth ACM Symposium on Operating Systems Principles (Bolton Landing, NY, USA) (SOSP ’03). Association for Computing Machinery, New York, NY, USA, 237–252. https://doi.org/10.1145/945445.945468
  30. Azadeh Farzan and P. Madhusudan. 2008. Monitoring Atomicity in Concurrent Programs. In Computer Aided Verification, 20th International Conference, CAV 2008, Princeton, NJ, USA, July 7-14, 2008, Proceedings (Lecture Notes in Computer Science, Vol. 5123), Aarti Gupta and Sharad Malik (Eds.). Springer, 52–65. https://doi.org/10.1007/978-3-540-70545-1_8
  31. Azadeh Farzan and P. Madhusudan. 2009. The Complexity of Predicting Atomicity Violations. In Tools and Algorithms for the Construction and Analysis of Systems, 15th International Conference, TACAS 2009, Held as Part of the Joint European Conferences on Theory and Practice of Software, ETAPS 2009, York, UK, March 22-29, 2009. Proceedings (Lecture Notes in Computer Science, Vol. 5505), Stefan Kowalewski and Anna Philippou (Eds.). Springer, 155–169. https://doi.org/10.1007/978-3-642-00768-2_14
  32. Predicting null-pointer dereferences in concurrent programs. In 20th ACM SIGSOFT Symposium on the Foundations of Software Engineering (FSE-20), SIGSOFT/FSE’12, Cary, NC, USA - November 11 - 16, 2012, Will Tracz, Martin P. Robillard, and Tevfik Bultan (Eds.). ACM, 47. https://doi.org/10.1145/2393596.2393651
  33. Colin Fidge. 1991. Logical Time in Distributed Computing Systems. Computer 24, 8 (Aug. 1991), 28–33. https://doi.org/10.1109/2.84874
  34. Cormac Flanagan and Stephen N. Freund. 2009. FastTrack: Efficient and Precise Dynamic Race Detection. In Proceedings of the 30th ACM SIGPLAN Conference on Programming Language Design and Implementation (Dublin, Ireland) (PLDI ’09). Association for Computing Machinery, New York, NY, USA, 121–133. https://doi.org/10.1145/1542476.1542490
  35. Cormac Flanagan and Stephen N. Freund. 2010. The RoadRunner Dynamic Analysis Framework for Concurrent Programs. In Proceedings of the 9th ACM SIGPLAN-SIGSOFT Workshop on Program Analysis for Software Tools and Engineering (Toronto, Ontario, Canada) (PASTE ’10). Association for Computing Machinery, New York, NY, USA, 1–8. https://doi.org/10.1145/1806672.1806674
  36. Types for atomicity: Static checking and inference for Java. ACM Trans. Program. Lang. Syst. 30, 4 (2008), 20:1–20:53. https://doi.org/10.1145/1377492.1377495
  37. Velodrome: a sound and complete dynamic atomicity checker for multithreaded programs. In Proceedings of the ACM SIGPLAN 2008 Conference on Programming Language Design and Implementation, Tucson, AZ, USA, June 7-13, 2008, Rajiv Gupta and Saman P. Amarasinghe (Eds.). ACM, 293–303. https://doi.org/10.1145/1375581.1375618
  38. Cormac Flanagan and Patrice Godefroid. 2005. Dynamic Partial-Order Reduction for Model Checking Software. In Proceedings of the 32nd ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (Long Beach, California, USA) (POPL ’05). Association for Computing Machinery, New York, NY, USA, 110–121. https://doi.org/10.1145/1040305.1040315
  39. Cormac Flanagan and Shaz Qadeer. 2003. A type and effect system for atomicity. In Proceedings of the ACM SIGPLAN 2003 Conference on Programming Language Design and Implementation 2003, San Diego, California, USA, June 9-11, 2003, Ron Cytron and Rajiv Gupta (Eds.). ACM, 338–349. https://doi.org/10.1145/781131.781169
  40. Probabilistic Concurrency Testing for Weak Memory Programs. In Proceedings of the 28th ACM International Conference on Architectural Support for Programming Languages and Operating Systems, Volume 2 (Vancouver, BC, Canada) (ASPLOS 2023). Association for Computing Machinery, New York, NY, USA, 603–616. https://doi.org/10.1145/3575693.3575729
  41. Giuseppe De Giacomo and Moshe Y. Vardi. 2013. Linear Temporal Logic and Linear Dynamic Logic on Finite Traces. In IJCAI 2013, Proceedings of the 23rd International Joint Conference on Artificial Intelligence, Beijing, China, August 3-9, 2013, Francesca Rossi (Ed.). IJCAI/AAAI, 854–860. https://doi.org/10.5555/2540128.2540252
  42. Phillip B. Gibbons and Ephraim Korach. 1997. Testing Shared Memories. SIAM J. Comput. 26, 4 (1997), 1208–1244. https://doi.org/10.1137/S0097539794279614
  43. Maurice Herlihy and Jeannette M. Wing. 1990. Linearizability: A Correctness Condition for Concurrent Objects. ACM Trans. Program. Lang. Syst. 12, 3 (1990), 463–492. https://doi.org/10.1145/78969.78972
  44. Jeff Huang. 2018. UFO: predictive concurrency use-after-free detection. In Proceedings of the 40th International Conference on Software Engineering, ICSE 2018, Gothenburg, Sweden, May 27 - June 03, 2018, Michel Chaudron, Ivica Crnkovic, Marsha Chechik, and Mark Harman (Eds.). ACM, 609–619. https://doi.org/10.1145/3180155.3180225
  45. GPredict: Generic Predictive Concurrency Analysis. In 37th IEEE/ACM International Conference on Software Engineering, ICSE 2015, Florence, Italy, May 16-24, 2015, Volume 1, Antonia Bertolino, Gerardo Canfora, and Sebastian G. Elbaum (Eds.). IEEE Computer Society, 847–857. https://doi.org/10.1109/ICSE.2015.96
  46. Maximal Sound Predictive Race Detection with Control Flow Abstraction. In Proceedings of the 35th ACM SIGPLAN Conference on Programming Language Design and Implementation (Edinburgh, United Kingdom) (PLDI ’14). Association for Computing Machinery, New York, NY, USA, 337–348. https://doi.org/10.1145/2594291.2594315
  47. Toward Integration of Data Race Detection in DSM Systems. J. Parallel and Distrib. Comput. 59, 2 (1999), 180–203. https://doi.org/10.1006/jpdc.1999.1574
  48. 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
  49. JavaMOP: Efficient parametric runtime monitoring framework. In 34th International Conference on Software Engineering, ICSE 2012, June 2-9, 2012, Zurich, Switzerland, Martin Glinz, Gail C. Murphy, and Mauro Pezzè (Eds.). IEEE Computer Society, 1427–1430. https://doi.org/10.1109/ICSE.2012.6227231
  50. A randomized dynamic program analysis technique for detecting real deadlocks. In Proceedings of the 2009 ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI 2009, Dublin, Ireland, June 15-21, 2009, Michael Hind and Amer Diwan (Eds.). ACM, 110–120. https://doi.org/10.1145/1542476.1542489
  51. Christian Gram Kalhauge and Jens Palsberg. 2018. Sound Deadlock Prediction. Proc. ACM Program. Lang. 2, OOPSLA, Article 146 (Oct. 2018), 29 pages. https://doi.org/10.1145/3276516
  52. Lazy Diagnosis of In-Production Concurrency Bugs. In Proceedings of the 26th Symposium on Operating Systems Principles (Shanghai, China) (SOSP ’17). Association for Computing Machinery, New York, NY, USA, 582–598. https://doi.org/10.1145/3132747.3132767
  53. Java-MaC: A Run-Time Assurance Approach for Java Programs. Formal Methods Syst. Des. 24, 2 (2004), 129–155. https://doi.org/10.1023/B:FORM.0000017719.43755.7C
  54. Dynamic Race Prediction in Linear-Time. In Proceedings of the 38th ACM SIGPLAN Conference on Programming Language Design and Implementation (Barcelona, Spain) (PLDI 2017). Association for Computing Machinery, New York, NY, USA, 157–170. https://doi.org/10.1145/3062341.3062374
  55. Data Race Detection on Compressed Traces. In Proceedings of the 2018 26th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering (Lake Buena Vista, FL, USA) (ESEC/FSE 2018). Association for Computing Machinery, New York, NY, USA, 26–37. https://doi.org/10.1145/3236024.3236025
  56. Truly Stateless, Optimal Dynamic Partial Order Reduction. Proc. ACM Program. Lang. 6, POPL, Article 49 (jan 2022), 28 pages. https://doi.org/10.1145/3498711
  57. Model checking for weakly consistent libraries. In Proceedings of the 40th ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI 2019, Phoenix, AZ, USA, June 22-26, 2019, Kathryn S. McKinley and Kathleen Fisher (Eds.). ACM, 96–110. https://doi.org/10.1145/3314221.3314609
  58. Ron Koymans. 1990. Specifying Real-Time Properties with Metric Temporal Logic. Real Time Syst. 2, 4 (1990), 255–299. https://doi.org/10.1007/BF01995674
  59. Dynamic Data-Race Detection Through the Fine-Grained Lens. In 32nd International Conference on Concurrency Theory, CONCUR 2021, August 24-27, 2021, Virtual Conference (LIPIcs, Vol. 203), Serge Haddad and Daniele Varacca (Eds.). Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 16:1–16:23. https://doi.org/10.4230/LIPICS.CONCUR.2021.16
  60. How good are the specs? a study of the bug-finding effectiveness of existing Java API specifications. In Proceedings of the 31st IEEE/ACM International Conference on Automated Software Engineering, ASE 2016, Singapore, September 3-7, 2016, David Lo, Sven Apel, and Sarfraz Khurshid (Eds.). ACM, 602–613. https://doi.org/10.1145/2970276.2970356
  61. Oded Maler and Dejan Nickovic. 2004. Monitoring Temporal Properties of Continuous Signals. In Formal Techniques, Modelling and Analysis of Timed and Fault-Tolerant Systems, Joint International Conferences on Formal Modelling and Analysis of Timed Systems, FORMATS 2004 and Formal Techniques in Real-Time and Fault-Tolerant Systems, FTRTFT 2004, Grenoble, France, September 22-24, 2004, Proceedings (Lecture Notes in Computer Science, Vol. 3253), Yassine Lakhnech and Sergio Yovine (Eds.). Springer, 152–166. https://doi.org/10.1007/978-3-540-30206-3_12
  62. Umang Mathur. 2023. RAPID. https://github.com/umangm/rapid Accessed: 2023-10-25.
  63. What Happens-after the First Race? Enhancing the Predictive Power of Happens-before Based Dynamic Race Detection. Proc. ACM Program. Lang. 2, OOPSLA, Article 145 (oct 2018), 29 pages. https://doi.org/10.1145/3276515
  64. A Tree Clock Data Structure for Causal Orderings in Concurrent Executions. In Proceedings of the 27th ACM International Conference on Architectural Support for Programming Languages and Operating Systems (Lausanne, Switzerland) (ASPLOS ’22). Association for Computing Machinery, New York, NY, USA, 710–725. https://doi.org/10.1145/3503222.3507734
  65. The Complexity of Dynamic Data Race Prediction. In Proceedings of the 35th Annual ACM/IEEE Symposium on Logic in Computer Science (Saarbrücken, Germany) (LICS ’20). Association for Computing Machinery, New York, NY, USA, 713–727. https://doi.org/10.1145/3373718.3394783
  66. Optimal Prediction of Synchronization-Preserving Races. Proc. ACM Program. Lang. 5, POPL, Article 36 (jan 2021), 29 pages. https://doi.org/10.1145/3434317
  67. Umang Mathur and Mahesh Viswanathan. 2020. Atomicity Checking in Linear Time using Vector Clocks. In ASPLOS ’20: Architectural Support for Programming Languages and Operating Systems, Lausanne, Switzerland, March 16-20, 2020, James R. Larus, Luis Ceze, and Karin Strauss (Eds.). ACM, 183–199. https://doi.org/10.1145/3373376.3378475
  68. Friedemann Mattern. 1989. Virtual Time and Global States of Distributed Systems. In Parallel and Distributed Algorithms: proceedings of the International Workshop on Parallel & Distributed Algorithms, M. Cosnard et. al. (Ed.). Elsevier Science Publishers B. V., 215–226.
  69. Antoni Mazurkiewicz. 1987. Trace theory. In Petri Nets: Applications and Relationships to Other Models of Concurrency, W. Brauer, W. Reisig, and G. Rozenberg (Eds.). Springer Berlin Heidelberg, Berlin, Heidelberg, 278–324.
  70. Robert McNaughton and Seymour Papert. 1971. Counter-Free Automata.
  71. Efficient monitoring of parametric context-free patterns. Autom. Softw. Eng. 17, 2 (2010), 149–180. https://doi.org/10.1007/S10515-010-0063-Y
  72. Scalable Statistical Root Cause Analysis on App Telemetry. In Proceedings of the 43rd International Conference on Software Engineering: Software Engineering in Practice (Virtual Event, Spain) (ICSE-SEIP ’21). IEEE Press, 288–297. https://doi.org/10.1109/ICSE-SEIP52600.2021.00038
  73. Madan Musuvathi and Shaz Qadeer. 2006. CHESS: Systematic Stress Testing of Concurrent Software. In Logic-Based Program Synthesis and Transformation, 16th International Symposium, LOPSTR 2006, Venice, Italy, July 12-14, 2006, Revised Selected Papers (Lecture Notes in Computer Science, Vol. 4407), Germán Puebla (Ed.). Springer, 15–16. https://doi.org/10.1007/978-3-540-71410-1_2
  74. Effective Static Race Detection for Java. In Proceedings of the 27th ACM SIGPLAN Conference on Programming Language Design and Implementation (Ottawa, Ontario, Canada) (PLDI ’06). Association for Computing Machinery, New York, NY, USA, 308–319. https://doi.org/10.1145/1133981.1134018
  75. VSync: push-button verification and optimization for synchronization primitives on weak memory models. In ASPLOS ’21: 26th ACM International Conference on Architectural Support for Programming Languages and Operating Systems, Virtual Event, USA, April 19-23, 2021, Tim Sherwood, Emery D. Berger, and Christos Kozyrakis (Eds.). ACM, 530–545. https://doi.org/10.1145/3445814.3446748
  76. Edward Ochmański. 1985. Regular behaviour of concurrent systems. Bull. EATCS 27 (1985), 56–67.
  77. Trace aware random testing for distributed systems. Proc. ACM Program. Lang. 3, OOPSLA (2019), 180:1–180:29. https://doi.org/10.1145/3360606
  78. Andreas Pavlogiannis. 2019. Fast, Sound, and Effectively Complete Dynamic Race Prediction. Proc. ACM Program. Lang. 4, POPL, Article 17 (dec 2019), 29 pages. https://doi.org/10.1145/3371085
  79. Amir Pnueli. 1977. The Temporal Logic of Programs. In Proceedings of the 18th Annual Symposium on Foundations of Computer Science (SFCS ’77). IEEE Computer Society, USA, 46–57. https://doi.org/10.1109/SFCS.1977.32
  80. Eli Poznianski and Assaf Schuster. 2003. Efficient On-the-Fly Data Race Detection in Multithreaded C++ Programs. In 17th International Parallel and Distributed Processing Symposium (IPDPS 2003), 22-26 April 2003, Nice, France, CD-ROM/Abstracts Proceedings. IEEE Computer Society, 287. https://doi.org/10.1109/IPDPS.2003.1213513
  81. Jake Roemer and Michael D. Bond. 2019. Online Set-Based Dynamic Analysis for Sound Predictive Race Detection. CoRR abs/1907.08337 (2019). arXiv:1907.08337 http://arxiv.org/abs/1907.08337
  82. High-coverage, unbounded sound predictive race detection. In Proceedings of the 39th ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI 2018, Philadelphia, PA, USA, June 18-22, 2018, Jeffrey S. Foster and Dan Grossman (Eds.). ACM, 374–389. https://doi.org/10.1145/3192366.3192385
  83. SmartTrack: efficient predictive race detection. In Proceedings of the 41st ACM SIGPLAN International Conference on Programming Language Design and Implementation, PLDI 2020, London, UK, June 15-20, 2020, Alastair F. Donaldson and Emina Torlak (Eds.). ACM, 747–762. https://doi.org/10.1145/3385412.3385993
  84. Grigore Rosu and Klaus Havelund. 2005. Rewriting-Based Techniques for Runtime Verification. Autom. Softw. Eng. 12, 2 (2005), 151–197. https://doi.org/10.1007/S10515-005-6205-Y
  85. Grigore Rosu and Mahesh Viswanathan. 2003. Testing Extended Regular Language Membership Incrementally by Rewriting. In Rewriting Techniques and Applications, 14th International Conference, RTA 2003, Valencia, Spain, June 9-11, 2003, Proceedings (Lecture Notes in Computer Science, Vol. 2706), Robert Nieuwenhuis (Ed.). Springer, 499–514. https://doi.org/10.1007/3-540-44881-0_35
  86. Lessons from Building Static Analysis Tools at Google. Commun. ACM 61, 4 (mar 2018), 58–66. https://doi.org/10.1145/3188720
  87. Generating Data Race Witnesses by an SMT-Based Analysis. In NASA Formal Methods - Third International Symposium, NFM 2011, Pasadena, CA, USA, April 18-20, 2011. Proceedings (Lecture Notes in Computer Science, Vol. 6617), Mihaela Gheorghiu Bobaru, Klaus Havelund, Gerard J. Holzmann, and Rajeev Joshi (Eds.). Springer, 313–327. https://doi.org/10.1007/978-3-642-20398-5_23
  88. Eraser: A Dynamic Data Race Detector for Multithreaded Programs. ACM Trans. Comput. Syst. 15, 4 (1997), 391–411. https://doi.org/10.1145/265924.265927
  89. M.P. Schützenberger. 1965. On finite monoids having only trivial subgroups. Information and Control 8, 2 (1965), 190–194. https://doi.org/10.1016/S0019-9958(65)90108-7
  90. Detecting Errors in Multithreaded Programs by Generalized Predictive Analysis of Executions. In Proceedings of the 7th IFIP WG 6.1 International Conference on Formal Methods for Open Object-Based Distributed Systems (Athens, Greece) (FMOODS’05). Springer-Verlag, Berlin, Heidelberg, 211–226. https://doi.org/10.1007/11494881_14
  91. Koushik Sen and Grigore Rosu. 2003. Generating Optimal Monitors for Extended Regular Expressions. In Third Workshop on Run-time Verification, RV@CAV 2003, Boulder, Colorado, USA, July 14, 2003 (Electronic Notes in Theoretical Computer Science, Vol. 89), Oleg Sokolsky and Mahesh Viswanathan (Eds.). Elsevier, 226–245. https://doi.org/10.1016/S1571-0661(04)81051-X
  92. Online efficient predictive safety analysis of multithreaded programs. Int. J. Softw. Tools Technol. Transf. 8, 3 (2006), 248–260. https://doi.org/10.1007/S10009-005-0192-Y
  93. Maximal Causal Models for Sequentially Consistent Systems. In Runtime Verification, Third International Conference, RV 2012, Istanbul, Turkey, September 25-28, 2012, Revised Selected Papers (Lecture Notes in Computer Science, Vol. 7687), Shaz Qadeer and Serdar Tasiran (Eds.). Springer, 136–150. https://doi.org/10.1007/978-3-642-35632-2_16
  94. Konstantin Serebryany and Timur Iskhodzhanov. 2009. ThreadSanitizer: Data Race Detection in Practice. In Proceedings of the Workshop on Binary Instrumentation and Applications (New York, New York, USA) (WBIA ’09). Association for Computing Machinery, New York, NY, USA, 62–71. https://doi.org/10.1145/1791194.1791203
  95. Predicting Serializability Violations: SMT-Based Search vs. DPOR-Based Search. In Hardware and Software: Verification and Testing - 7th International Haifa Verification Conference, HVC 2011, Haifa, Israel, December 6-8, 2011, Revised Selected Papers (Lecture Notes in Computer Science, Vol. 7261), Kerstin Eder, João Lourenço, and Onn Shehory (Eds.). Springer, 95–114. https://doi.org/10.1007/978-3-642-34188-5_11
  96. Sound predictive race detection in polynomial time. In Proceedings of the 39th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL 2012, Philadelphia, Pennsylvania, USA, January 22-28, 2012, John Field and Michael Hicks (Eds.). ACM, 387–400. https://doi.org/10.1145/2103656.2103702
  97. A Parallel Java Grande Benchmark Suite. In Proceedings of the 2001 ACM/IEEE Conference on Supercomputing (Denver, Colorado) (SC ’01). ACM, New York, NY, USA, 8–8. https://doi.org/10.1145/582034.582042
  98. PENELOPE: weaving threads to expose atomicity violations. In Proceedings of the 18th ACM SIGSOFT International Symposium on Foundations of Software Engineering, 2010, Santa Fe, NM, USA, November 7-11, 2010, Gruia-Catalin Roman and André van der Hoek (Eds.). ACM, 37–46. https://doi.org/10.1145/1882291.1882300
  99. Sound Dynamic Deadlock Prediction in Linear Time. Proc. ACM Program. Lang. 7, PLDI (2023), 1733–1758. https://doi.org/10.1145/3591291
  100. Associating synchronization constraints with data in an object-oriented language. In Proceedings of the 33rd ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL 2006, Charleston, South Carolina, USA, January 11-13, 2006, J. Gregory Morrisett and Simon L. Peyton Jones (Eds.). ACM, 334–345. https://doi.org/10.1145/1111037.1111067
  101. RELAY: static race detection on millions of lines of code. In Proceedings of the 6th joint meeting of the European Software Engineering Conference and the ACM SIGSOFT International Symposium on Foundations of Software Engineering, 2007, Dubrovnik, Croatia, September 3-7, 2007, Ivica Crnkovic and Antonia Bertolino (Eds.). ACM, 205–214. https://doi.org/10.1145/1287624.1287654
  102. Virginia Vassilevska Williams. 2018. On some fine-grained questions in algorithms and complexity. In Proceedings of the International Congress of Mathematicians: Rio de Janeiro 2018. World Scientific, 3447–3487. https://doi.org/10.1142/9789813272880_0188
  103. Partial Order Aware Concurrency Sampling. In Computer Aided Verification - 30th International Conference, CAV 2018, Held as Part of the Federated Logic Conference, FloC 2018, Oxford, UK, July 14-17, 2018, Proceedings, Part II (Lecture Notes in Computer Science, Vol. 10982), Hana Chockler and Georg Weissenbacher (Eds.). Springer, 317–335. https://doi.org/10.1007/978-3-319-96142-2_20
Citations (5)
View on Semantic Scholar

Summary

We haven't generated a summary for this paper yet.

Ai Sparkles Streamline Icon: https://streamlinehq.com Summarize Now