Erez Petrank
Madanlal Musuvathi
ABSTRACT
Parallel platforms are becoming ubiquitous with modern computing systems. Many parallel applications attempt to avoid locks in order to achieve high responsiveness, aid scalability, and avoid deadlocks and livelocks. However, avoiding the use of system locks does not guarantee that no locks are actually used, because progress inhibitors may occur in subtle ways through various program structures. Notions of progress guarantee such as lock-freedom, wait-freedom, and obstruction-freedom have been proposed in the literature to provide various levels of progress guarantees.
In this paper we formalize the notions of progress guarantees using linear temporal logic (LTL). We concentrate on lock-freedom and propose a variant of it denoted bounded lock-freedom, which is more suitable for guaranteeing progress in practical systems. We use this formal definition to build a tool that checks if a concurrent program is bounded lock-free for a given bound. We then study the interaction between programs with progress guarantees and the underlying system (e.g., compilers, runtimes, operating systems, and hardware platforms). We propose a means to argue that an underlying system supports lock-freedom. A composition theorem asserts that bounded lock-free algorithms running on bounded lock-free supporting systems retain bounded lock-freedom for the composed execution.
- Lawrence Bush. Lock free linked list using compare & swap. http://www.cs.rpi.edu/ bushl2/project web/page5.html, April 2002.Google Scholar
- David L. Detlefs, Paul A. Martin, Mark Moir, and Guy L. Steele. Lock-free reference counting. Distributed Computing, 15: 255--271, 2002. Google ScholarDigital Library
- 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. Google ScholarDigital Library
- Cynthia Dwork, Nancy Lynch, and Larry Stockmeyer. Consensus in the presence of partial synchrony. Journal of the ACM, 35(2):288--323, 1988. Google ScholarDigital Library
- Faith Ellen Fich, Victor Luchangco, Mark Moir, and Nir Shavit. Obstruction-free algorithms can be practically wait-free. In DISC, pages 78--92, 2005. Google ScholarDigital Library
- 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.Google Scholar
- 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. Google ScholarDigital Library
- Brian Goetz, Tim Peierls, Joshua Block, Joseph Bowbeer, David Holmes, and Doug Lea. Java Concurrency in Practice. Addison-Wesley, 2006.Google ScholarDigital Library
- 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, POPL 2009, pages 16--28. ACM, 2009. Google ScholarDigital Library
- Maurice Herlihy. Wait-free synchronization. ACM Transactions on Programming Languages and Systems, 13(1):124--149, January 1991. Google ScholarDigital Library
- 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. Google ScholarDigital Library
- 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. Google ScholarDigital Library
- Maurice Herlihy and Nir Shavit. The Art of Multiprocessor Programming. Morgan Kaufmann, March 2008. Google ScholarDigital Library
- 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. Google ScholarDigital Library
- Henry Massalin. Synthesis: An Efficient Implementation of Fundamental Operating System Services. PhD thesis, Columbia University, 1992. Google ScholarDigital Library
- Michael Merritt and Gadi Taubenfeld. Computing with infinitely many processes. In DISC '00: Proceedings of the 14th International Conference on Google ScholarDigital Library
- Distributed Computing, pages 164---178. Springer--Verlag, 2000.Google Scholar
- Maged Michael. Scalable lock--free dynamic memory allocation. In Proceedings of SIGPLAN 2004 Conference on Programming Languages Design Google ScholarDigital Library
- and Implementation, ACM SIGPLAN Notices, Washington, DC, June 2004. ACM Press.Google Scholar
- Maged M. Michael. Safe memory reclamation for dynamic lock--free objects using atomic reads and writes. In Proceedings of the 21st Annual ACM Google ScholarDigital Library
- Symposium on Principles of Distributed Computing, pages 21---30, July 2002.Google Scholar
- Maged M. Michael. Practical lock--free and wait--free LL/SC/VL implementations using 64--bit CAS. In Proceedings of the 18th International ConferenceGoogle Scholar
- on Distributed Computing, volume 3274 of LNCS, pages 144---158. Springer--Verlag, October 2004.Google Scholar
- Maged M. Michael. Scalable lock--free dynamic memory allocation. In Proceedings of the 2004 ACM SIGPLAN Conference on Programming Language Google ScholarDigital Library
- Design and Implementation, pages 35---46, June 2004.Google Scholar
- Maged M. Michael and Michael L. Scott. Simple, fast, and practical non--blocking and blocking concurrent queue algorithms. In Proceedings of theGoogle Scholar
- 15th International Symposium on Principles of Distributed Computing, pages 267---275, May 1996.Google Scholar
- Madanlal Musuvathi, Shaz Qadeer, Thomas Ball, Gerard Basler, Piramanayagam Arumuga Nainar, and Iulian Neamtiu. Finding and reproducingGoogle Scholar
- heisenbugs in concurrent programs. In OSDI 08: Operating Systems Design and Implementation, pages 267---280, 2008. Google ScholarDigital Library
- Filip Pizlo, Daniel Frampton, Erez Petrank, and Bjarne Steensgard. STOPLESS: A real--time garbage collector for multiprocessors. In Mooly Sagiv,Google Scholar
- editor, ISMM'07 Proceedings of the Fifth International Symposium on Memory Management, pages 159---172, Montr´Google Scholar
- eal, Canada, October 2007. ACMGoogle Scholar
- Press.Google Scholar
- Filip Pizlo, Erez Petrank, and Bjarne Steensgaard. A study of concurrent real--time garbage collectors. In Proceedings of SIGPLAN 2008 Conference on Google ScholarDigital Library
- Programming Languages Design and Implementation, ACM SIGPLAN Notices, pages 33---44, Tucson, AZ, June 2008. ACM Press.Google Scholar
- Amir Pnueli. The temporal logic of programs. In FOCS 77: Foundations of Computer Science, pages 46---57, 1977. Google ScholarDigital Library
- John D. Valois. Lock--free linked lists using compare--and--swap. In Proceedings of the fourteenth annual ACM symposium on Principles of distributed Google ScholarDigital Library
- computing, pages 214---222, Ottawa, Ontario, CA, 1995.Google Scholar
Index Terms
- Progress guarantee for parallel programs via bounded lock-freedom
Recommendations
Progress guarantee for parallel programs via bounded lock-freedom
PLDI '09Parallel platforms are becoming ubiquitous with modern computing systems. Many parallel applications attempt to avoid locks in order to achieve high responsiveness, aid scalability, and avoid deadlocks and livelocks. However, avoiding the use of system ...
LOFT: lock-free transactional data structures
PPoPP '19: Proceedings of the 24th Symposium on Principles and Practice of Parallel ProgrammingConcurrent data structures are widely used in modern multicore architectures, providing atomicity (linearizability) for each concurrent operation. However, it is often desirable to execute several operations on multiple data structures atomically. We ...
Separating Lock-Freedom from Wait-Freedom
PODC '18: Proceedings of the 2018 ACM Symposium on Principles of Distributed ComputingA long-standing open question has been whether lock-freedom and wait-freedom are fundamentally different progress conditions, namely, can the former be provided in situations where the latter cannot? This paper answers the question in the affirmative, ...
Comments