Transient blocking synchronization

We introduce Transient Blocking Synchronization (TBS), a new approach to hardware synchronization for mega-scale distributed-memory multiprocessor machines. Such machines, with thousands of processors and controller based memory modules, are essentially distributed networks, and one must search for new paradigms that provide hardware synchronization support with high levels of robustness and minimal protocol and communication overhead. It is our claim that the semantics of non-blocking synchronization primitives such as Compare &Swap and LoadLinked/StoreConditional on the one hand, and blocking ones such as Full/Empty-bits on the other, will introduce high communication and space costs when implemented on large scale machines. TBS is a novel hardware synchronization paradigm resting between the classic blocking and non-blocking approaches to synchronization. It is an example of how, based on very weak "transient" hardware blocking, that is, blocking that may be revoked at any time, one can provide non-blocking universal synchronization with low communication and space complexity. This paper presents a set of simple TBS single-location synchronization operations and shows that they provide low cost non-blocking emulations of all known read-modify-write operations. Moreover, it shows that the combination of TBS with hardware supported transactional bits, a variation on traditional hardware full/empty bits, can provide low message cost implementations of multi-word transactional operations.

[1]  Nir Shavit,et al.  Software transactional memory , 1995, PODC '95.

[2]  Keir Fraser,et al.  Language support for lightweight transactions , 2003, SIGP.

[3]  Maurice Herlihy,et al.  Obstruction-free synchronization: double-ended queues as an example , 2003, 23rd International Conference on Distributed Computing Systems, 2003. Proceedings..

[4]  Maurice Herlihy,et al.  Wait-free synchronization , 1991, TOPL.

[5]  David Dice,et al.  Implementing Fast Java Monitors with Relaxed-Locks , 2001, Java Virtual Machine Research and Technology Symposium.

[6]  Maurice Herlihy,et al.  Software transactional memory for dynamic-sized data structures , 2003, PODC '03.

[7]  Y. S. Ramakrishna,et al.  An efficient meta-lock for implementing ubiquitous synchronization , 1999, OOPSLA '99.

[8]  Maged M. Michael.  Safe memory reclamation for dynamic lock-free objects using atomic reads and writes , 2002, PODC '02.

[9]  Keir Fraser,et al.  A Practical Multi-word Compare-and-Swap Operation , 2002, DISC.

[10]  Maurice Herlihy,et al.  The Repeat Offender Problem: A Mechanism for Supporting Dynamic-Sized, Lock-Free Data Structures , 2002, DISC.

[11]  Mark Moir.  Practical implementations of non-blocking synchronization primitives , 1997, PODC '97.

[12]  David R. Cheriton,et al.  Leases: an efficient fault-tolerant mechanism for distributed file cache consistency , 1989, SOSP '89.

[13]  Mark Moir,et al.  Nonblocking k-compare-single-swap , 2003, SPAA '03.

[14]  Allan Porterfield,et al.  The Tera computer system , 1990, ICS '90.

[15]  Ralph E. Droms,et al.  Dynamic Host Configuration Protocol , 1993, RFC.

[16]  Donald Yeung,et al.  THE MIT ALEWIFE MACHINE: A LARGE-SCALE DISTRIBUTED-MEMORY MULTIPROCESSOR , 1991 .

[17]  Mauricio J. Serrano,et al.  Thin locks: featherweight Synchronization for Java , 2004, SIGP.

[18]  Maurice Herlihy,et al.  Transactional Memory: Architectural Support For Lock-free Data Structures , 1993, Proceedings of the 20th Annual International Symposium on Computer Architecture.