Algorithms for Scalable Synchronization on Shared-Memory Multiprocessors

DMCA

Algorithms for Scalable Synchronization on Shared-Memory Multiprocessors (1991)

Cached

Download Links

Other Repositories/Bibliography

DBLP

by John M. Mellor-crummey , Michael L. Scott

Venue:	ACM Transactions on Computer Systems
Citations:	573 - 32 self

BibTeX

@ARTICLE{Mellor-crummey91algorithmsfor,
    author = {John M. Mellor-crummey and Michael L. Scott},
    title = {Algorithms for Scalable Synchronization on Shared-Memory Multiprocessors},
    journal = {ACM Transactions on Computer Systems},
    year = {1991},
    volume = {9},
    pages = {21--65}
}

OpenURL

Abstract

Busy-wait techniques are heavily used for mutual exclusion and barrier synchronization in shared-memory parallel programs. Unfortunately, typical implementations of busy-waiting tend to produce large amounts of memory and interconnect contention, introducing performance bottlenecks that become markedly more pronounced as applications scale. We argue that this problem is not fundamental, and that one can in fact construct busy-wait synchronization algorithms that induce no memory or interconnect contention. The key to these algorithms is for every processor to spin on separate locally-accessible ag variables, and for some other processor to terminate the spin with a single remote write operation at an appropriate time. Flag variables may be locally-accessible as a result of coherent caching, or by virtue of allocation in the local portion of physically distributed shared memory. We present a new scalable algorithm for spin locks that generates O(1) remote references per lock acquisition, independent of the number of processors attempting to acquire the lock. Our algorithm provides reasonable latency in the absence of contention, requires only a constant amount of space per lock, and requires no hardware support other than

Keyphrases

scalable synchronization shared-memory multiprocessor interconnect contention hardware support separate locally-accessible ag variable shared memory mutual exclusion barrier synchronization flag variable reasonable latency shared-memory parallel program lock acquisition remote reference typical implementation local portion single remote write operation busy-waiting tend new scalable algorithm constant amount appropriate time performance bottleneck busy-wait technique fact construct busy-wait synchronization spin lock coherent caching large amount