Progress guarantee for parallel programs via bounded lock-freedom

Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI)

Volumn , Issue , 2009, Pages 144-154

  Petrank, Erez ^a   Musuvathi, Madanlal ^b   Steensgaard, Bjarne ^b  

^a TECHNION ISRAEL INSTITUTE OF TECHNOLOGY   (Israel)

^b MICROSOFT RESEARCH   (United States)

Author keywords

Bounded lock freedom; Lock freedom; Model checking; Parallel computation; Progress guarantees

Indexed keywords

COMPOSITION THEOREM; COMPUTING SYSTEM; CONCURRENT PROGRAM; FORMAL DEFINITION; HARDWARE PLATFORM; LINEAR TEMPORAL LOGIC; LOCK-FREE; LOCK-FREE ALGORITHMS; LOCK-FREEDOM; OPERATING SYSTEMS; PARALLEL APPLICATION; PARALLEL COMPUTATION; PARALLEL PLATFORMS; PARALLEL PROGRAM; PRACTICAL SYSTEMS; PROGRAM STRUCTURES; RUNTIMES; SUPPORTING SYSTEMS; UNDERLYING SYSTEMS; WAIT-FREEDOM;

C (PROGRAMMING LANGUAGE); COMPUTER OPERATING SYSTEMS; LINGUISTICS; LOCKS (FASTENERS); PARALLEL ARCHITECTURES; TEMPORAL LOGIC; UBIQUITOUS COMPUTING;

MODEL CHECKING;

EID: 70450230477     PISSN: None     EISSN: None     Source Type: Conference Proceeding    
DOI: 10.1145/1542476.1542493     Document Type: Conference Paper

References (26)

1. Lawrence Bush. Lock free linked list using compare & swap. http://www.cs.rpi.edu/bushl2/project.web/page5.html, April 2002.
2. David L. Detlefs, Paul A. Martin, Mark Moir, and Guy L. Steele. Lock-free reference counting. Distributed Computing, 15:255-271, 2002.
3. Brijesh Dongol. Formalising progress properties of non-blocking programs. In Formal Methods and Software Engineering, 8th International Conference on Formal Engineering Methods, ICFEM 2006, pages 284-303, 2006.
4. Cynthia Dwork, Nancy Lynch, and Larry Stockmeyer. Consensus in the presence of partial synchrony. Journal of the ACM, 35(2):288-323, 1988.
5. Faith Ellen Fich, Victor Luchangco, Mark Moir, and Nir Shavit. Obstruction-free algorithms can be practically wait-free. In DISC, pages 78-92, 2005.
6. Anders Gidenstam, Marina Papatriantafilou, Håkon Sundell, and Philippas Tsigas. Practical and efficient lock-free garbage collection based on reference counting. Technical Report 04, Chalmers University of Technology and Göteborg University, 2005.
7. Anders Gidenstam, Marina Papatriantafilou, and Philippas Tsigas. Allocating memory in a lock-free manner. In Proceedings of the 13th Annual European Symposium on Algorithms, number 3669 in LNCS, pages 329-342. Springer-Verlag, October 2005.
8. Brian Goetz, Tim Peierls, Joshua Block, Joseph Bowbeer, David Holmes, and Doug Lea. Java Concurrency in Practice. Addison-Wesley, 2006.
9. Alexey Gotsman, Byron Cook, Matthew Parkinson, and Viktor Vafeiadis. Proving that non-blocking algorithms don't block. In Zhong Shao and Benjamin C. Pierce, editors, Proceedings of the 36th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL2009, pages 16-28. ACM, 2009.
10. Maurice Herlihy. Wait-free synchronization. ACM Transactions on Programming Languages and Systems, 13(1):124-149, January 1991.
11. Maurice Herlihy, Victor Luchangco, Paul Martin, and Mark Moir. Nonblocking memory management support for dynamically-sized data structures. ACM Transactions on Computer Systems, 23 (2): 146-196, May 2005.
12. Maurice Herlihy, Victor Luchangco, and Mark Moir. Obstruction-free synchronization: Double-ended queues as an example. In Proceedings of the 23rd International Conference on Distributed Computing Systems, pages 522-529, May 2003.
13. Maurice Herlihy and Nir Shavit. The Art of Multiprocessor Programming. Morgan Kaufmann, March 2008.
14. Prasad Jayanti. A complete and constant time wait-free implementation of cas from ll/sc and vice versa. In Proceedings of the 12th International Symposium on Distributed Computing, volume 1499 of LNCS, pages 216-230, September 1998.
15. Henry Massalin. Synthesis: An Efficient Implementation of Fundamental Operating System Services. PhD thesis, Columbia University, 1992.
16. Michael Merritt and Gadi Taubenfeld. Computing with infinitely many processes. In DISC '00: Proceedings of the 14th International Conference on Distributed Computing, pages 164-178. Springer-Verlag, 2000.
17. Maged Michael. Scalable lock-free dynamic memory allocation. In Proceedings of SIGPLAN 2004 Conference on Programming Languages Design and Implementation, ACM SIGPLAN Notices, Washington, DC, June 2004. ACM Press.
18. Maged M. Michael. Safe memory reclamation for dynamic lock-free objects using atomic reads and writes. In Proceedings of the 21st Annual ACM Symposium on Principles of Distributed Computing, pages 21-30, July 2002.
19. Maged M. Michael. Practical lock-free and wait-free LL/SC/VL implementations using 64-bit CAS. In Proceedings of the 18th International Conference on Distributed Computing, volume 3274 of LNCS, pages 144-158. Springer-Verlag, October 2004.
20. Maged M. Michael. Scalable lock-free dynamic memory allocation. In Proceedings of the 2004 ACM SIGPLAN Conference on Programming Language Design and Implementation, pages 35-46, June 2004.
21. Maged M. Michael and Michael L. Scott. Simple, fast, and practical non-blocking and blocking concurrent queue algorithms. In Proceedings of the 15th International Symposium on Principles of Distributed Computing, pages 267-275, May 1996.
22. Madanlal Musuvathi, Shaz Qadeer, Thomas Ball, Gerard Basler, Piramanayagam Arumuga Nainar, and Iulian Neamtiu. Finding and reproducing heisenbugs in concurrent programs. In OSDI 08: Operating Systems Design and Implementation, pages 267-280, 2008.
23. Filip Pizlo, Daniel Frampton, Erez Petrank, and Bjarne Steensgard. STOPLESS: A real-time garbage collector for multiprocessors. In Mooly Sagiv, editor, ISMM'07 Proceedings of the Fifth International Symposium on Memory Management, pages 159-172, Montréal, Canada, October 2007. ACM Press.
24. Filip Pizlo, Erez Petrank, and Bjarne Steensgaard. A study of concurrent real-time garbage collectors. In Proceedings of SIGPLAN 2008 Conference on Programming Languages Design and Implementation, ACM SIGPLAN Notices, pages 33-44, Tucson, AZ, June 2008. ACM Press.
25. Amir Pnueli. The temporal logic of programs. In FOCS 77: Foundations of Computer Science, pages 46-57, 1977.
26. John D. Valois. Lock-free linked lists using compare-and-swap. In Proceedings of the fourteenth annual ACM symposium on Principles of distributed computing, pages 214-222, Ottawa, Ontario, CA, 1995.