Delegation with Trust<T>: A Scalable, Type- and Memory-Safe Alternative to Locks
<|reference_start|>Delegation with Trust<T>: A Scalable, Type- and Memory-Safe Alternative to Locks: 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.<|reference_end|>
@article{ahmad2024delegation,
    title={Delegation with Trust<T>: A Scalable, Type- and Memory-Safe Alternative
  to Locks},
    author={Noaman Ahmad, Ben Baenen, Chen Chen, and Jakob Eriksson},
    journal={arXiv preprint arXiv:2408.11173},
    year={2024},
    archivePrefix={arXiv},
    eprint={2408.11173},
    primaryClass={cs.PF cs.OS}
}