Reciprocating Locks

Abstract: We present "Reciprocating Locks", a novel mutual exclusion locking algorithm, targeting cache-coherent shared memory (CC), that enjoys a number of desirable properties. The doorway arrival phase and the release operation both run in constant-time. Waiting threads use local spinning and only a single waiting element is required per thread, regardless of the number of locks a thread might hold at a given time. While our lock does not provide strict FIFO admission, it bounds bypass and has strong anti-starvation properties. The lock is compact, space efficient, and has been intentionally designed to be readily usable in real-world general purpose computing environments such as the linux kernel, pthreads, or C++. We show the lock exhibits high throughput under contention and low latency in the uncontended case. The performance of Reciprocating Locks is competitive with and often better than the best state-of-the-art scalable spin locks.

• The paper introduces Reciprocating Locks, a novel mutual exclusion algorithm for cache-coherent systems with constant-time operations and local spinning.
• Performance benchmarks show Reciprocating Locks achieve high throughput and low latency, often outperforming state-of-the-art alternatives like MCS and CLH.
• The lock's practical design, featuring constant-time operations and efficiency, makes it suitable for real-world use in environments like the Linux kernel and C++ applications.

Analysis of "Reciprocating Locks" by Dice and Kogan

The paper introduces a novel mutual exclusion algorithm termed "Reciprocating Locks," designed specifically for cache-coherent shared memory architectures. Its salient features include a constant-time doorway and release operation, local spinning, and space efficiency, making it a practicable choice for real-world use in environments like the Linux kernel or in programming languages like C++.

Algorithm Description

Reciprocating Locks employ an innovative partitioning method under contention, segmenting waiting threads into arrival and entry segments. Threads join the stack using atomic operations, with succession handled primarily through the entry segment to avoid starvation. Should the entry segment be depleted, the arrival segment, formed via atomic exchanges, becomes the successor entry segment, ensuring fairness and minimizing contention-induced bottlenecks.

The lock structure utilizes an "arrival word," encoding lock holdings states like 0 for unlocked, 1 for simple locked, and others for threads stacked waiting for access. The algorithm eschews reliance on explicit FIFO queuing, yet it maintains fair access by bounding bypass scenarios, striking a balance between practical fairness and system throughput.

Implementation Nuances

Implementing Reciprocating Locks involves a carefully orchestrated interaction between atomic operations and local spinning on thread-specific waiting elements. This requires conscious efforts in over-fencing in C++ atomic std::-atomic operations to maintain both clarity and succinctness in the reciprocal succession mechanism. Notably, the use of stack-based implicit access patterns mitigates complexities associated with linked lists in other competing lock designs like the MCS or CLH locks.

Empirical Performance

The Performance benchmarks highlight that Reciprocating Locks deliver high throughput under contention and maintains low latency in uncontended situations. It generally outperforms or matches state-of-the-art alternatives like MCS, CLH, and HemLock, especially in hyper-threaded and multi-core environments. An essential takeaway is the lock's minimalistic imposition on remote memory references and coherence traffic, crucial on platforms like NUMA, which enhances scalability.

Theoretical and Practical Implications

Theoretically, Reciprocating Locks present a strong case for broader adoption in environments heavily reliant on concurrency control without necessitating complex lifecycle management seen in other lock implementations. The compact lock structure aligns well with requirements for environments such as the Linux kernel, where prompt lock destruction safety, support for numerous threads and locks, and local spinning optimization, are vital.

Moreover, the algorithm's willful avoidance of strict FIFO scheduling opens avenues for higher throughput at the expense of sticking to rigid lock admission schedules. This trade-off aligns with observed practices in practical settings where usability and performance take precedence over theoretical fairness constraints.

Future Directions

Continued development could explore optimizations like the coherence traffic reduction technique adopted from HemLock and employing the CLDEMOTE instruction to further refine ownership conveyance. Addressing potential statistical admission unfairness through randomized succession perturbation remains an open area, reinforcing long-term fairness without degrading throughput or starvation guarantees.

In conclusion, Reciprocating Locks encapsulate a pragmatic balance of theoretical elegance and practical efficiency, poised as a resilient mutex solution adaptable across diverse computing architectures. The proposed design contributes valuable insights and techniques, setting a foundational blueprint for subsequent advancements in mutual exclusion mechanisms.