Progress guarantee for parallel programs via bounded lock-freedom

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, waitfreedom, 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.

Liveness-Preserving Atomicity Abstraction

“…Besides, the work of Filipović et al did not justify any compositional proof methods, as we have done in Theorem 4. Petrank et al [13] were the first to observe that lock-freedom is compositional, as we prove in Theorem 9. However, their formulation and 'proof' of this property are presented as a piece of informal text talking about artefacts without a clear semantics.…”

Characterizing Progress Properties of Concurrent Objects via Contextual Refinements

“…For example, Petrank et al [15] formalize the three non-blocking properties and Dongol [3] formalize all the five progress properties, using linear temporal logics. Those formulations make it easier to do model checking (e.g., Petrank et al [15] also build a tool to model check a variant of lock-freedom), while our contextual refinement framework is potentially helpful for modular Hoare-style verification.…”

Progress Guarantees When Composing Lock-Free Objects

“…Two Algorithm 1. A template of a lock-free object 1 13 Object src 16 synchronization primitives that are commonly used are Compare-And-Swap (CAS), Load-Link/Store-Conditional (LL/SC). CAS [12] takes three arguments: an address, an expected value, and an update value.…”