CompCertTSO: A verified compiler for relaxed-memory concurrency

Journal of the ACM

Volumn 60, Issue 3, 2013, Pages

  Ševčík, Jaroslav ^a   Vafeiadis, Viktor ^b   Nardelli, Francesco Zappa ^c   Jagannathan, Suresh ^d   Sewell, Peter ^e  

^a MICROSOFT   (United States)

^b MAX PLANCK INSTITUTE FOR SOFTWARE SYSTEMS   (Germany)

^c INRIA   (France)

^d PURDUE UNIVERSITY   (United States)

^e UNIVERSITY OF CAMBRIDGE   (United Kingdom)

Author keywords

Relaxed memory models; Semantics; Verified compilation

Indexed keywords

ASSEMBLY LANGUAGE; COMPILER OPTIMIZATIONS; CONCURRENT ALGORITHMS; OBSERVABLE BEHAVIOR; PROGRAMMING MODELS; RELAXED MEMORY MODELS; SEMANTIC DESIGN; VERIFIED COMPILATION;

MULTIPROCESSING SYSTEMS; SEMANTICS;

PROGRAM COMPILERS;

EID: 84880356634     PISSN: 00045411     EISSN: 1557735X     Source Type: Journal    
DOI: 10.1145/2487241.2487248     Document Type: Article

References (63)

1. Martn Abadi and Leslie Lamport. 1991. The existence of refinement mappings. Theoret. Comput. Sci. 253-284.
2. Sarita V. Adve and Mark D. Hill. 1990. Weak ordering-a new definition. In Proceedings of the 17th International Symposium on Computer Architecture (ISCA). ACM, New York, 2-14. DOI:http://dx.doi.org/10.1145/325164.325100.
3. Jade Alglave. 2010. A shared memory poetics. Ph.D. dissertation. Université Paris 7.
4. Jade Alglave, Luc Maranget, Susmit Sarkar, and Peter Sewell. 2010. Fences in weak memory models. In Proceedings of the 22nd International Conference on Computer Aided Verification (CAV). Springer-Verlag, Berlin, Heidelberg, 258-272. DOI:http://dx.doi.org/10.1007/978-3-642-14295-6-25.
5. Mark Batty, Scott Owens, Susmit Sarkar, Peter Sewell, and Tjark Weber. 2011. Mathematizing C++ concurrency. In Proceedings of the 38th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL). ACM, New York, 55-66. DOI:http://dx.doi.org/10.1145/1926385.1926394.
6. Mark Batty, Kayvan Memarian, Scott Owens, Susmit Sarkar, and Peter Sewell. 2012. Clarifying and compiling C/C++ concurrency: From C++11 to POWER. In Proceedings of the 39th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL). ACM, New York, 509-520. DOI:http://dx.doi.org/10. 1145/2103656.2103717.
7. Pete Becker Ed. 2011. Programming Languages - C++, ISO/IEC 14882:2011 (N3242).
8. DOI:http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3242.pdf (last accessed 5/13). (N3242 is a near-final draft standard which is available online).
9. Nick Benton and Chung-Kil Hur. 2009. Biorthogonality, step-indexing and compiler correctness. In Proceedings of the 14th ACM SIGPLAN International Conference on Functional Programming (ICFP). ACM, New York, 97-108. DOI:http://dx.doi.org/10.1145/1596550.1596567.
10. Sandrine Blazy and Xavier Leroy. 2009. Mechanized semantics for the Clight subset of the C language. J. Automat. Reason. 43, 3, 263-288.
11. Hans-J. Boehm. 2005. Threads cannot be implemented as a library. In Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI). ACM, New York, 261-268. DOI:http://dx.doi.org/10.1145/ 1065010.1065042.
12. Hans-J. Boehm and Sarita V. Adve. 2008. Foundations of the C++ concurrency memory model. In Proceedings of the SIGPLAN Conference on Programming Language Design and Implementation (PLDI). ACM, New York, 68-78. DOI:http://dx.doi.org/10.1145/1375581.1375591.
13. Sebastian Burckhardt, Rajeev Alur, and Milo M. K. Martin. 2007. CheckFence: Checking consistency of concurrent data types on relaxed memory models. In Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI). ACM, New York, 12-21. DOI:http://dx.doi.org/ 10.1145/1250734.1250737.
14. Sebastian Burckhardt, Madanlal Musuvathi, and Vasu Singh. 2010. Verifying local transformations on relaxed memory models. In Proceedings of the International Conference on Compiler Construction (CC). Springer-Verlag, Berlin, 104-123. DOI:http://dx.doi.org/10.1007/978-3-642-11970-5-7.
15. Chi Cao Minh, JaeWoong Chung, Christos Kozyrakis, and Kunle Olukotun. 2008. STAMP: Stanford transac-tional applications for multi-processing. In Proceedings of the IEEE International Symposium on Workload Characterization (IISWC). 35-46.
16. Pietro Cenciarelli, Alexander Knapp, and Eleonora Sibilio. 2007. The Java memory model: Operationally, de-notationally, axiomatically. In Proceedings of the 16th European Symposium on Programming (ESOP). Lecture Notes in Computer Science, vol. 4421, Springer-Verlag, Berlin, 331-346. DOI:http://dx.doi.org/10. 1007/978-3-540-71316-6-23.
17. Adam Chlipala. 2010. A verified compiler for an impure functional language. In Proceedings of the 37th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL). ACM, New York, 93-106. DOI:http://dx.doi.org/10.1145/1706299.1706312.
18. COQ. 2011. The Coq proof assistant. http://coq.inria.fr/, version 8.3pl1.
19. Dave Dice, Ori Shalev, and Nir Shavit. 2006. Transactional locking II. In Proceedings of the 20th International Conference on Distributed Computing (DISC). Springer-Verlag, Berlin, 194-208. DOI:http://dx.doi.org/10.1007/ 11864219-14.
20. Keir Fraser. 2003. Practical lock freedom. Ph.D. dissertation. University of Cambridge.
21. Georges Gonthier and Assia Mahboubi. 2007. A small scale reflection extension for the Coq system. Tech.rep. 6455. INRIA.
22. Aquinas Hobor, Andrew W. Appel, and Francesco Zappa Nardelli. 2008. Oracle semantics for concurrent separation logic. In Proceedings of the European Symposium on Programming (ESOP). Lecture Notes in Computer Science, vol. 4960. Springer-Verlag, Berlin, 353-367. DOI:http://dx.doi.org/10.1007/978-3-540-78739- 6-27.
23. Thuan Quang Huynh and Abhik Roychoudhury. 2007. Memory model sensitive bytecode verification. Formal Methods in System Design 31, 3, 281-305.
24. ISO. 2011. Programming languages - C, ISO/IEC 9899:2011 (N1547). http://www.open-std.org/jtc1/sc22/wg14/www/docs/PostBatavia.tar.bz2 (last accessed 5/13). (N1547 is a near-final draft standard which is available online).
25. Michael Kuperstein, Martin Vechev, and Eran Yahav. 2010. Automatic inference of memory fences. In Proceedings of the Formal Methods in Computer-Aided Design (FMCAD). FMCAD Inc., Austin, TX, 111-120. DOI:http://dx.doi.org/10.1145/2261417.2261438.
26. Leslie Lamport. 1979. How to make a multiprocessor computer that correctly executes multiprocess programs. IEEE Trans. Comput. C-28, 9, 690-691.
27. Doug Lea. 1999. Concurrent Programming in Java 2nd Ed. Design Principles and Patterns. Addison-Wesley Longman Publishing Co., Inc., Boston, MA.
28. Jaejin Lee and David A. Padua. 2001. Hiding relaxed memory consistency with a compiler. IEEE Trans. Comput. 50, 824-833. Issue 8.
29. Xavier Leroy. 2009a. The compcert verified compiler, v. 1.5. http://compcert.inria.fr/release/compcert-1.5.tgz (last accessed 5/13).
30. Xavier Leroy. 2009b. Formal verification of a realistic compiler. Comm. ACM 52, 7, 107-115.
31. Xavier Leroy. 2009c. A formally verified compiler back-end. J. Automat. Reason. 43, 4, 363-446.
32. Xavier Leroy. 2013. The Compcert verified compiler, v. 1.12.1. (2013). http://compcert.inria.fr/release/compcert-1.12.1.tgz (last accessed 5/13).
33. Xavier Leroy and Sandrine Blazy. 2008. Formal verification of a C-like memory model and its uses for verifying program transformations. J. Automat. Reason. 41, 1, 1-31.
34. Linux. 1999. Linux Kernel mailing list, thread "spin unlock optimization(i386)", 119 messages, Nov. 20-Dec. 7th. http://www.gossamer- threads.com/lists/engine?post=105365;list=linux (last accessed 5/13).
35. Andreas Lochbihler. 2010. Verifying a compiler for Java threads. In Proceedings of the European Symposium on Programming (ESOP). A. D. Gordon Ed., Springer, 427-447. DOI:http://dx.doi.org/10.1007/978-3-642-11957-6-23.
36. Andreas Lochbihler. 2012. Java and the Java memory model-a unified, machine-checked formalisation. In Proceedings of the European Symposium on Programming (ESOP). Springer-Verlag, Berlin, 497-517. DOI:http://dx.doi.org/10. 1007/978-3-642-28869-2-25.
37. Nancy Lynch and Frits Vaandrager. 1995. Forward and backward simulations I: Untimed systems. Inf. Comput. 121, 2, 214-233.
38. Jeremy Manson, William Pugh, and Sarita V. Adve. 2005. The Java memory model. In Proceedings of the 32nd ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL). ACM, New York, 378-391. DOI:http://dx.doi.org/10. 1145/1040305.1040336.
39. Daniel Marino, Abhayendra Singh, Todd Millstein, Madanlal Musuvathi, and Satish Narayanasamy. 2011. A case for an SC-preserving compiler. In Proceedings of the 32nd ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI). ACM, New York, 199-210. DOI:http://dx.doi.org/10.1145/ 1993498.1993522.
40. John McCarthy and James Painter. 1967. Correctness of a compiler for arithmetic expressions. In Proceedings of a Symposium in Applied Mathematics. Vol. 19, Mathematical Aspects of Computer Science, J. T. Schwartz Ed., American Mathematical Society, Providence, R.I., 33-41.
41. Robin Milner. 1989. Communication and Concurrency. Prentice Hall International.
42. Robin Milner and R. Weyrauch. 1972. Proving compiler correctness in a mechanized logic. In Machine Intelligence 7, B. Meltzer and D. Michie Eds., American Elsevier, New York, 51-70.
43. Etienne Morel and Claude Renvoise. 1979. Global optimization by suppression of partial redundancies. Comm. ACM22, 2, 96-103.
44. Magnus O. Myreen. 2010. Verified just-in-time compiler on x86. In Proceedings of the 37th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL). ACM, New York, 107-118.DOI:http://dx.doi.org/10. 1145/1706299.1706313.
45. Scott Owens. 2010. Reasoning about the implementation of concurrency abstractions on x86-TSO. In Proceedings of the 24th European Conference on Object-Oriented Programming (ECOOP). Lecture Notes in Computer Science, vol. 6183. Springer-Verlag, Berlin, 478-503. DOI:http://dx.doi.org/10.1007/978-3-642- 14107-2-23.
46. Scott Owens, Susmit Sarkar, and Peter Sewell. 2009. A better x86 memory model: x86-TSO. In Proceedings of the 22nd International Conference on Theorem Proving in Higher Order Logics (TPHOLs). Lecture Notes in Computer Science, vol. 5674. Springer-Verlag, Berlin, 391-407. DOI:http://dx.doi.org/10.1007/978-3- 642-03359-9-27.
47. William Pugh. 2000. The Java memory model is fatally flawed. Concurrency Pract. Exper. 12, 6, 445-455.
48. Susmit Sarkar, Peter Sewell, Francesco Zappa Nardelli, Scott Owens, Tom Ridge, Thomas Braibant, Magnus O. Myreen, and Jade Alglave. 2009. The semantics of x86-CC multiprocessor machine code. In Proceedings of the 36th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL). ACM, New York, 379-391. DOI:http://dx.doi.org/10.1145/1480881.1480929.
49. Susmit Sarkar, Peter Sewell, Jade Alglave, Luc Maranget, and Derek Williams. 2011. Understanding POWER multiprocessors. In Proceedings of the 32nd ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI). ACM, New York, 175-186. DOI:http://dx.doi.org/10.1145/1993498.1993520.
50. Susmit Sarkar, Kayvan Memarian, Scott Owens, Mark Batty, Peter Sewell, Luc Maranget, Jade Alglave, and Derek Williams. 2012. Synchronising C/C++ and POWER. In Proceedings of the 33rd ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI). ACM, New York, 311-322. DOI:http://dx.doi. org/10.1145/2254064.2254102.
51. Jaroslav Sevćik and David Aspinall. 2008. On validity of program transformations in the Java memory model. In Proceedings of the 22nd European Conference on Object-Oriented Programming (ECOOP). Springer-Verlag, Berlin, 27-51. DOI:http://dx.doi.org/10.1007/978-3-540-70592-5-3.
52. Jaroslav Sevćik, Viktor Vafeiadis, Francesco Zappa Nardelli, Suresh Jagannathan, and Peter Sewell. 2011. Relaxed-memory concurrency and verified compilation. In Proceedings of the 38th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL). ACM, New York, 43-54.DOI:http://dx.doi.org/10.1145/1926385.1926393.
53. Peter Sewell. 1997. On implementations and semantics of a concurrent programming language. In Proceedings of the 8th International Conference on Concurrency Theory (CONCUR). Lecture Notes in Computer Science, Springer-Verlag, Berlin, 391-405. DOI:http://dx.doi.org/10.1007/3-540-63141-0-27.
54. Peter Sewell, Susmit Sarkar, Scott Owens, Francesco Zappa Nardelli, and Magnus O. Myreen. 2010a. x86-TSO: A rigorous and usable programmer's model for x86 multiprocessors. Comm. ACM 53, 7, 89-97.
55. Peter Sewell, Francesco Zappa Nardelli, Scott Owens, Gilles Peskine, Thomas Ridge, Susmit Sarkar, and Rok Strnisa. 2010b. Ott: Effective tool support for the working semanticist. J. Function. Prog. 20, 1, 71-122.
56. Dennis Shasha and Marc Snir. 1988. Efficient and correct execution of parallel programs that share memory. ACM Trans. Prog. Lang. Syst. 10, 2, 282-312.
57. SPARC International, Inc. 1992. The SPARC Architecture Manual, V 8, Revision SAV080SI9308. http://www.sparc.org/standards/V8.pdf (last accessed 5/13).
58. SPARC International, Inc. 1994. The SPARC Architecture Manual, V 9. http://www.sparc.com/standards/SPARCV9.pdf (last accessed 5/13).
59. Gordon Stewart and Andrew W Appel. 2011. Local actions for a curry-style operational semantics. In Proceedings of the 5th ACM Workshop on Programming Languages Meets Program Verification (PLPV). ACM, New York, 31-42. DOI:http://dx.doi.org/10.1145/1929529.1929535.
60. Zehra Sura, Xing Fang, Chi-Leung Wong, Samuel P. Midkiff, Jaejin Lee, and David Padua. 2005. Compiler techniques for high performance sequentially consistent Java programs. In Proceedings of the 10th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming (PPoPP). ACM, New York, 2-13. DOI:http://dx.doi.org/10.1145/1065944.1065947.
61. Emina Torlak, Mandana Vaziri, and Julian Dolby. 2010. MemSAT: Checking axiomatic specifications of memory models. In Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI). ACM, New York, 341-350. DOI:http://dx.doi.org/10.1145/1806596.1806635.
62. R. Kent Treiber. 1986. Systems programming: Coping with parallelism. Tech. rep. TR RJ 5118. IBM.
63. Viktor Vafeiadis and Francesco Zappa Nardelli. 2011. Verifying fence elimination optimisations. In Proceedings of the 18th International Conference on Static Analysis (SAS). Springer-Verlag, Berlin, 146-162. DOI:http://dx.doi. org/10.1007/978-3-642-23702-7-14.