Abstract
Shared counters are the key to solving a variety of coordination problems on multiprocessor machines, such as barrier synchronization and index distribution. It is desired that they, like shared objects in general, be robust, linearizable and scalable.
We present the first linearizable and wait-free shared counter algorithm that achieves high throughput without a-priori knowledge about the system’s level of asynchrony. Our algorithm can be easily adapted to any other combinable objects as well, such as stacks and queues.
In particular, in an N-process execution E, our algorithm achieves high throughput of \(\Omega(\frac{N}{\phi_{E}^{2}\log^{2}{\phi_{E}}\log{N}})\), where φ E is E’s level of asynchrony. Moreover, our algorithm stands any constant number of faults. If E contains a constant number of faults, then our algorithm still achieves high throughput of \(\Omega(\frac{N}{\phi'^{2}_{E}\log^{2}{\phi'_{E}}\log{N}})\), where φ′ E bounds the relative speeds of any two processes, at a time that both of them participated in E and none of them failed.
Our algorithm can be viewed as an adaptive version of the Bounded-Wait-Combining (BWC) prior art algorithm. BWC receives as an input an argument φ as a (supposed) upper bound of φ E , and achieves optimal throughput if φ = φ E . However, if the given φ happens to be lower than the actual φ E , or much greater than φ E , then the throughput of BWC degraded significantly. Moreover, whereas BWC is only lock-free, our algorithm is more robust, since it is wait-free.
To achieve high throughput and wait-freedom, we present a method that guarantees (for some common kind of procedures) the procedure’s successful termination in a bounded time, regardless of shared memory contention. This method may prove useful by itself, for other problems.
Access this chapter
Tax calculation will be finalised at checkout
Purchases are for personal use only
Preview
Unable to display preview. Download preview PDF.
References
Aspnes, J., Herlihy, M., Shavit, N.: Counting networks. STOC 23, 348–358 (1991)
Chandra, T.D., Jayanti, P., Tan, K.: A Polylog Time Wait-Free Construction for Closed Objects. PODC 17, 287–296 (1998)
Dolev, D., Dwork, C., Stockmeyer, L.: On the Minimal Synchronism Needed for Distributed Consensus. JACM 34, 77–97 (1987)
Dwork, C., Herlihy, M., Waarts, O.: Contention in shared memory algorithms. STOC 25, 174–183 (1993)
Dwork, C., Lynch, N., Stockmeyer, L.: Consensus in the Presence of Partial Synchrony. JACM 35, 288–323 (1988)
Ellen, F., Lev, Y., Luchangco, V., Moir, M.: SNZI: scalable NonZero indicators. PODC 26, 13–22 (2007)
Goodman, J.R., Vernon, M.K., Woest, P.J.: Efficient Synchronization Primitives for Large-Scale Cache-Coherent Multiprocessors. ASPLOS 3, 64–75 (1989)
Gottlieb, A., Grishman, R., Kruskal, C.P., McAuliffe, K.P., Rudolph, L., Snir, M.: The NYU ultracomputer - designing a MIMD, shared-memory parallel machine. ISCA 9, 239–254 (1998)
Gray, C., Cheriton, D.: Leases: an efficient fault-tolerant mechanism for distributed file cache consistency. SOSP 12, 202–210 (1989)
Greenwald, M.: Two-Handed Emulation: How to build Non-Blocking implementations of Complex Data-Structures using DCAS. PODC 21, 260–269 (2002)
Ha, P.H., Papatriantafilou, M., Tsigas, P.: Self-tuning Reactive Distributed Trees for Counting and Balancing. OPODIS 8, 213–228 (2004)
Hendler, D., Kutten, S.: Constructing shared objects that are both robust and high-throughput. DISC 20, 428–442 (2006)
Hendler, D., Kutten, S., Michalak, E.: An Adaptive Technique for Constructing Robust and High-Throughput Shared Objects - Technical Report, http://ie.technion.ac.il/~kutten/hkm2010.pdf
Hendler, D., Shavit, N., Yerushalmi, L.: A scalable lock-free stack algorithm. SPAA 16, 206–215 (2004)
Herlihy, M.: Wait-free synchronization. TOPLAS 13, 124–149 (1991)
Herlihy, M., Shavit, N., Waarts, O.: Linearizable Counting Networks. FOCS 32, 526–535 (1991)
Herlihy, M., Wing, J.M.: Linearizability: a correctness condition for concurrent objects. TOPLAS 12, 463–492 (1990)
Moir, M., Nussbaum, D., Shalev, O., Shavit, N.: Using elimination to implement scalable and lock-free FIFO queues. SPAA 17, 253–262 (2005)
Shavit, N., Zemach, A.: Diffracting trees. SPAA 6, 167–176 (1994)
Author information
Authors and Affiliations
Editor information
Editors and Affiliations
Rights and permissions
Copyright information
© 2010 Springer-Verlag Berlin Heidelberg
About this paper
Cite this paper
Hendler, D., Kutten, S., Michalak, E. (2010). An Adaptive Technique for Constructing Robust and High-Throughput Shared Objects. In: Lu, C., Masuzawa, T., Mosbah, M. (eds) Principles of Distributed Systems. OPODIS 2010. Lecture Notes in Computer Science, vol 6490. Springer, Berlin, Heidelberg. https://doi.org/10.1007/978-3-642-17653-1_24
Download citation
DOI: https://doi.org/10.1007/978-3-642-17653-1_24
Publisher Name: Springer, Berlin, Heidelberg
Print ISBN: 978-3-642-17652-4
Online ISBN: 978-3-642-17653-1
eBook Packages: Computer ScienceComputer Science (R0)