[Paper Review] Constant Amortized RMR Complexity Deterministic Abortable Mutual Exclusion Algorithm for CC and DSM Models

Prasad Jayanti, Siddhartha Jayanti|arXiv (Cornell University)|Sep 12, 2018

Distributed systems and fault tolerance13 references3 citations

TL;DR

This paper presents a deterministic, abortable mutual exclusion algorithm with O(1) amortized Remote Memory Reference (RMR) complexity for both Cache-Coherent (CC) and Distributed Shared Memory (DSM) models. It achieves constant amortized RMR cost using a novel potential function analysis, supports fast O(1) aborts, satisfies First-Come-First-Served semantics for abortable locks, and requires only the Fetch&Store atomic instruction, resolving a long-standing open problem in concurrent computing.

ABSTRACT

The abortable mutual exclusion problem was introduced by Scott and Scherer to meet a need that arises in database and real time systems, where processes sometimes have to abandon their attempt to acquire a mutual exclusion lock to initiate recovery from a potential deadlock or to avoid overshooting a deadline. Algorithms of O(1) RMR complexity have been known for the standard mutual exclusion problem for both the Cache-Coherent (CC) and Distributed Shared Memory (DSM) models of multiprocessors, but whether O(1) RMR complexity is also achievable for abortable mutual exclusion has remained open for the 18 years that this problem has been investigated. Jayanti gives a Theta(log n) worst case RMR complexity solution for both models, where n is the maximum number of processes that execute the algorithm concurrently. Giakouppis and Woelfel's algorithm, presented at PODC last year, is an O(1) amortized complexity algorithm, but it works only for the CC model, uses randomization, does not satisfy Starvation Freedom, and the O(1) amortized bound holds only in expectation and is proven for the a weak (oblivious) adversary model. We design an algorithm that is free of these limitations: our algorithm is deterministic, supports fast aborts (a process completes an abort in O(1) steps), has a small space complexity of O(n), requires hardware support for only the Fetch&Store instruction, satisfies a novely defined First Come First Served for abortable locks, and most importantly, has O(1) amortized RMR complexity for both the CC and DSM models. Our algorithm is short and practical with fewer than a dozen lines of code, and is accompanied by a rigorous proof of mutual exclusion through invariants and of starvation-freedom and complexity analysis through distance and potential functions. Thus, modulo amortization, our result answers affirmatively the long standing open question described above.

Motivation & Objective

• To resolve the long-standing open question of whether O(1) amortized RMR complexity is achievable for abortable mutual exclusion in both CC and DSM models.
• To design a deterministic algorithm that supports fast aborts (completed in O(1) steps) without relying on randomization.
• To ensure starvation freedom and First-Come-First-Served semantics for abortable locks, which previous algorithms failed to achieve.
• To minimize space complexity to O(n) while requiring only the Fetch&Store atomic instruction.
• To provide a rigorous proof of correctness using invariants and potential function analysis for complexity and liveness.

Proposed method

• The algorithm uses a linked list of nodes representing processes in order of their attempt to acquire the lock, with each process maintaining a pointer to its predecessor and successor.
• It employs a potential function based on the indicators of whether a process’s current node is in its local cache or partition, and whether it is in a critical state.
• The analysis uses distance and potential functions to bound the amortized RMR cost across all lines of code, ensuring O(1) amortized complexity.
• The algorithm leverages the Fetch&Store instruction to atomically update pointers and lock state, enabling efficient synchronization with minimal remote memory references.
• Starvation freedom is ensured by enforcing a First-Come-First-Served ordering on lock acquisition attempts, even during aborts.
• The proof of mutual exclusion is established via invariants that track the consistency of the linked list and lock state across process steps.

Experimental results

Research questions

• RQ1 Is O(1) amortized RMR complexity achievable for abortable mutual exclusion in both CC and DSM models?
• RQ2 Can a deterministic algorithm with O(1) amortized RMR complexity support fast aborts and starvation freedom?
• RQ3 Can such an algorithm be designed with minimal hardware support, requiring only Fetch&Store?
• RQ4 Does a potential function-based analysis suffice to prove O(1) amortized RMR complexity in both models?
• RQ5 Can the algorithm enforce First-Come-First-Served semantics for abortable locks while maintaining low RMR complexity?

Key findings

• The proposed algorithm achieves O(1) amortized RMR complexity for both CC and DSM models, answering affirmatively the long-standing open question in concurrent computing.
• The algorithm supports O(1) step aborts, allowing a process to abort its lock acquisition attempt in constant time without blocking.
• The algorithm is deterministic, starvation-free, and enforces First-Come-First-Served semantics for abortable locks, unlike prior randomized or non-starvation-free approaches.
• The space complexity is O(n), and only the Fetch&Store atomic instruction is required, minimizing hardware assumptions.
• The potential function analysis rigorously proves that the amortized RMR cost per operation is bounded by a constant, with line-by-line amortized cost analysis confirming O(1) bounds.
• The proof of mutual exclusion is established via invariants that preserve the consistency of the lock state and linked list structure across all process steps.