Delegation with Trust<T>: A Scalable, Type- and Memory-Safe Alternative to Locks

TL;DR

Trust<T> offers a scalable, type- and memory-safe alternative to traditional locks in concurrent programming by delegating object access to a trustee, significantly improving throughput under contention.

Contribution

The paper introduces Trust<T>, a novel delegation-based approach that replaces locks with a message-passing mechanism, enhancing scalability and safety in concurrent systems.

Findings

Up to 22x higher throughput in microbenchmarks under contention

5-9x throughput improvement in key-value stores and memcached

Competitive performance with locks when contention is low

Abstract

We present Trust<T>, a general, type- and memory-safe alternative to locking in concurrent programs. Instead of synchronizing multi-threaded access to an object of type T with a lock, the programmer may place the object in a Trust<T>. The object is then no longer directly accessible. Instead a designated thread, the object's trustee, is responsible for applying any requested operations to the object, as requested via the Trust<T> API. Locking is often said to offer a limited throughput per lock. Trust<T> is based on delegation, a message-passing technique which does not suffer this per-lock limitation. Instead, per-object throughput is limited by the capacity of the object's trustee, which is typically considerably higher. Our evaluation shows Trust<T> consistently and considerably outperforming locking where lock contention exists, with up to 22x higher throughput in microbenchmarks, and 5-9x for a home grown key-value store, as well as memcached, in situations with high lock contention. Moreover, Trust<T> is competitive with locks even in the absence of lock contention.