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 Scholar
Digital 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 Scholar
Digital 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 Scholar
Digital 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 Scholar
Digital 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 Scholar
Digital Library
- Brian Goetz, Tim Peierls, Joshua Block, Joseph Bowbeer, David Holmes, and Doug Lea. Java Concurrency in Practice. Addison-Wesley, 2006.Google Scholar
Digital 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 Scholar
Digital Library
- Maurice Herlihy. Wait-free synchronization. ACM Transactions on Programming Languages and Systems, 13(1):124--149, January 1991. Google Scholar
Digital 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 Scholar
Digital 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 Scholar
Digital Library
- Maurice Herlihy and Nir Shavit. The Art of Multiprocessor Programming. Morgan Kaufmann, March 2008. Google Scholar
Digital 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 Scholar
Digital Library
- Henry Massalin. Synthesis: An Efficient Implementation of Fundamental Operating System Services. PhD thesis, Columbia University, 1992. Google Scholar
Digital Library
- Michael Merritt and Gadi Taubenfeld. Computing with infinitely many processes. In DISC '00: Proceedings of the 14th International Conference on Google Scholar
Digital 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 Scholar
Digital 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 Scholar
Digital 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 Scholar
Digital 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 Scholar
Digital 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 Scholar
Digital 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 Scholar
Digital 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 Scholar
Digital 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 '09: Proceedings of the 30th ACM SIGPLAN Conference on Programming Language Design and ImplementationParallel 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 ...
Towards a universal construction for transaction-based multiprocess programs
ICDCN'12: Proceedings of the 13th international conference on Distributed Computing and NetworkingThe aim of a Software Transactional Memory (STM) system is to discharge the programmer from the explicit management of synchronization issues. The programmer's job resides in the design of multiprocess programs in which processes are made up of ...







Comments