Consensus in the presence of partial synchrony
Journal of the ACM (JACM)
ACM Transactions on Programming Languages and Systems (TOPLAS)
Synthesis: an efficient implementation of fundamental operating system services
Synthesis: an efficient implementation of fundamental operating system services
Lock-free linked lists using compare-and-swap
Proceedings of the fourteenth annual ACM symposium on Principles of distributed computing
Safe memory reclamation for dynamic lock-free objects using atomic reads and writes
Proceedings of the twenty-first annual symposium on Principles of distributed computing
A Complete and Constant Time Wait-Free Implementation of CAS from LL/SC and Vice Versa
DISC '98 Proceedings of the 12th International Symposium on Distributed Computing
Computing with Infinitely Many Processes
DISC '00 Proceedings of the 14th International Conference on Distributed Computing
Distributed Computing - Special issue: Selected papers from PODC '01
Obstruction-Free Synchronization: Double-Ended Queues as an Example
ICDCS '03 Proceedings of the 23rd International Conference on Distributed Computing Systems
Scalable lock-free dynamic memory allocation
Proceedings of the ACM SIGPLAN 2004 conference on Programming language design and implementation
Nonblocking memory management support for dynamic-sized data structures
ACM Transactions on Computer Systems (TOCS)
A study of concurrent real-time garbage collectors
Proceedings of the 2008 ACM SIGPLAN conference on Programming language design and implementation
The temporal logic of programs
SFCS '77 Proceedings of the 18th Annual Symposium on Foundations of Computer Science
Proving that non-blocking algorithms don't block
Proceedings of the 36th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
The Art of Multiprocessor Programming
The Art of Multiprocessor Programming
Finding and reproducing Heisenbugs in concurrent programs
OSDI'08 Proceedings of the 8th USENIX conference on Operating systems design and implementation
Allocating memory in a lock-free manner
ESA'05 Proceedings of the 13th annual European conference on Algorithms
Formalising progress properties of non-blocking programs
ICFEM'06 Proceedings of the 8th international conference on Formal Methods and Software Engineering
Obstruction-Free algorithms can be practically wait-free
DISC'05 Proceedings of the 19th international conference on Distributed Computing
Journal of Parallel and Distributed Computing
Liveness-preserving atomicity abstraction
ICALP'11 Proceedings of the 38th international conference on Automata, languages and programming - Volume Part II
Progress guarantees when composing lock-free objects
Euro-Par'11 Proceedings of the 17th international conference on Parallel processing - Volume Part II
Can parallel data structures rely on automatic memory managers?
Proceedings of the 2012 ACM SIGPLAN Workshop on Memory Systems Performance and Correctness
Proceedings of the twenty-fourth annual ACM symposium on Parallelism in algorithms and architectures
Characterizing progress properties of concurrent objects via contextual refinements
CONCUR'13 Proceedings of the 24th international conference on Concurrency Theory
Quantitative Reasoning for Proving Lock-Freedom
LICS '13 Proceedings of the 2013 28th Annual ACM/IEEE Symposium on Logic in Computer Science
| Hi-index | 0.00 |
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.