NSF Award
2315363
Modern software increasingly employs concurrent programming in order to exploit the performance benefits offered by multicore architectures. Unfortunately, concurrent programming is notoriously difficult and concurrency bugs exist even in code written by the most seasoned programmers. Consequently, researchers have developed mathematical reasoning techniques in attempt to prove these programs correct but existing techniques rely on the user to provide complex invariants that are often not very intuitive. By contrast, algorithm designers from the distributed computing community frequently provide more understandable arguments for the correctness of their implementations, by focusing on describing a few key example scenarios of how threads may be interleaved. This project will bridge this gap by elevating scenario-based reasoning from intuitive arguments to formally rigorous proofs. The project’s novelties are new foundations, algorithms and automated tools for verifying concurrent software that demonstrate how scenario-based reasoning can be formal, yet also approachable to everyday programmers. The project’s impacts are (1) theories, algorithms and automated verification tools for concurrent software that can be used by programmers, without the need for a background in formal methods, (2) demonstrated applicability to real-world concurrent programs such as web or databases servers, (3) publications and public open-source release of these verification tools, and (4) broader impacts on education through novel course materials and participation of under-represented groups. Overall, the project will make verification more accessible and, through our advocation in academia and in industry, lead to adoption and ultimately safer concurrent software.<br/><br/>Technically the project formalizes scenarios as a program's execution quotient, which captures a small set of representative interleaved executions that nonetheless generalize---via commutativity---to the set of all executions, even with unboundedly many threads and infinite state spaces. The project aims to demonstrate that these quotients can be described succinctly in a convenient language; that the proof of quotient soundness (i.e., that the abstraction covers all executions) can be systematized through new forms of induction that interact with commutativity; that it is possible to automatically derive quotients directly from source code; and that programmers can use these derivations and query them to better understand the concurrent behavior of their implementations.<br/><br/>This award reflects NSF's statutory mission and has been deemed worthy of support through evaluation using the Foundation's intellectual merit and broader impacts review criteria.
