• Documents
  • Authors
  • Tables
  • Log in
  • Sign up
  • MetaCart
  • DMCA
  • Donate

CiteSeerX logo

Advanced Search Include Citations
Advanced Search Include Citations

DMCA

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

Cached

  • Download as a PDF

Download Links

  • [www.csd.uoc.gr]
  • [www.cc.gatech.edu]
  • [calab.kaist.ac.kr]
  • [www.cc.gatech.edu]
  • [ftp.cs.rochester.edu]
  • [www.cs.rice.edu]
  • [www.eecg.toronto.edu]
  • [www.eecg.toronto.edu]
  • [www.cs.rice.edu]
  • [www.cs.utexas.edu]
  • [www.cs.toronto.edu]
  • [www.cse.usf.edu]
  • [www.cos.ufrj.br]
  • [www.cs.uiuc.edu]
  • [www.csee.usf.edu]
  • [www.cse.usf.edu]
  • [www.cos.ufrj.br]

  • Other Repositories/Bibliography

  • DBLP
  • Save to List
  • Add to Collection
  • Correct Errors
  • Monitor Changes
by John M. Mellor-crummey , Michael L. Scott
Venue:ACM Transactions on Computer Systems
Citations:573 - 32 self
  • Summary
  • Citations
  • Active Bibliography
  • Co-citation
  • Clustered Documents
  • Version History

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}
}

Share

Facebook Twitter Reddit Bibsonomy

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   

Powered by: Apache Solr
  • About CiteSeerX
  • Submit and Index Documents
  • Privacy Policy
  • Help
  • Data
  • Source
  • Contact Us

Developed at and hosted by The College of Information Sciences and Technology

© 2007-2019 The Pennsylvania State University