Simple and fast biased locks

Abstract

Locks are used to ensure exclusive access to shared memory locations. Unfortunately, lock operations are expensive, so much work has been done on optimizing their performance for common access patterns. One such pattern is found in networking applications, where there is a single thread dominating lock accesses. An important special case arises when a single-threaded program calls a thread-safe library that uses locks.An effective way to optimize the dominant-thread pattern is to "bias" the lock implementation so that accesses by the dominant thread have negligible overhead. We take this approach in this work: we simplify and generalize existing techniques for biased locks, producing a large design space with many trade-offs. For example, if we assume the dominant process acquires the lock infinitely often (a reasonable assumption for packet processing), it is possible to make the dominant process perform a lock operation without expensive fence or compare-and-swap instructions. This gives a very low overhead solution; we confirm its efficacy by experiments. We show how these constructions can be extended for lock reservation, re-reservation, and to reader-writer situations.

Efficient and thread-safe objects for dynamically-typed languages

“…Biased locking [32] is arguably the most popular technique in this domain. Biased locking relies on the assumption that locks are rarely contended, because even though a specific object might be accessed in parallel, often objects are only used temporarily by a single thread.…”

Compiler support for lightweight context switching

“…Two solutions proposed for this are to have the non-owner thread interrupt and pause the owner thread [Kawachiya et al 2002], or to have the owner thread poll for lock requests [Vasudevan et al 2010]. The former requires an expensive kernel call and fixup mechanism to pause the owner and take the lock, while the latter can exhibit starvation if the owner does not poll regularly.…”

“…Biased locking algorithms were proposed by Vasudevan et al [Vasudevan et al 2010]. Applications for the Java programming language, where syntax-level support for locks makes them a frequent construct even when not strictly necessary, were described by Russel and Detlefs [Russell and Detlefs 2006], Kawachiya et al [Kawachiya et al 2002] and Onodera et al [Onodera et al 2004].…”

Fast asymmetric thread synchronization

“…All these mechanisms are slow, and require significant interaction with the operating system. Vasudevan et al [2010] combine the ideas of tiered locks and SERIALIZE() into a single scheme. Like Onodera et al [2004] they use a two-tier locking scheme.…”