Abstract
Over the past decade, a pair of instructions called load-linked (LL) and store-conditional (SC) have emerged as the most suitable synchronization instructions for the design of lock-free algorithms. However, current architectures do not support these instructions; instead, they support either CAS (e.g., UltraSPARC, Itanium) or restricted versions of LL/SC (e.g., POWER4, MIPS, Alpha). To bridge this gap, a flurry of algorithms that implement LL/SC from CAS have appeared in the literature. Some of these algorithms assume that N, the maximum number of participating processes, is fixed and known in advance. Others make no such assumption, but are either non-blocking (not wait-free), implement small LL/SC objects, or require that a process performs O(N) work to join the algorithm. Specifically, no constant-time, word-sized, wait-free LL/SC algorithm that does not require the knowledge of N exists. In this paper, we present such an algorithm.
This work is partially supported by the NSF Award EIA-9802068.
This is a preview of subscription content, log in via an institution to check access.
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
Herlihy, M.: Wait-free synchronization. ACM TOPLAS 13, 124–149 (1991)
Lamport, L.: Concurrent reading and writing. Communications of the ACM 20, 806–811 (1977)
International, S.: (The SPARC Architecture Manual) Version 9.
Corporation, I.: Intel Itanium Architecture Software Developer’s Manual Volume 1: Application Architecture, Revision 2.1 (2002)
Group, I.S.: IBM e server POWER4 System Microarchitecture (2001)
Site, R.: Alpha Architecture Reference Manual. Digital Equipment Corporation (1992)
Center, I.T.W.R.: System/370 Principles of operation, Order Number GA22-7000 (1983)
Moir, M.: Practical implementations of non-blocking synchronization primitives. In: Proceedings of the 16th Annual ACM Symposium on Principles of Distributed Computing, pp. 219–228 (1997)
Afek, Y., Dauber, D., Touitou, D.: Wait-free made fast. In: Proceedings of the 27th Annual ACM Symposium on Theory of Computing, pp. 538–547 (1995)
Barnes, G.: A method for implementing lock-free shared data structures. In: Proceedings of the 5th Annual ACM Symposium on Parallel Algorithms and Architectures, pp. 261–270 (1993)
Herlihy, M.: A methodology for implementing highly concurrent data structures. ACM Transactions on Programming Languages and Systems 15, 745–770 (1993)
Jayanti, P.: f-arrays: implementation and applications. In: Proceedings of the 21st Annual Symposium on Principles of Distributed Computing, pp. 270–279 (2002)
Jayanti, P.: An optimal multi-writer snapshot algorithm. In: Proceedings of the 37th annual ACM symposium on Theory of computing, pp. 723–732 (2005)
Moir, M.: Transparent support for wait-free transactions. In: Mavronicolas, M. (ed.) WDAG 1997. LNCS, vol. 1320, pp. 305–319. Springer, Heidelberg (1997)
Moir, M.: Laziness pays! Using lazy synchronization mechanisms to improve non-blocking constructions. Distributed Computing 14, 193–204 (2001)
Shavit, N., Touitou, D.: Software transactional memory. In: Proceedings of the 14th Annual ACM Symposium on Principles of Distributed Computing, pp. 204–213 (1995)
Anderson, J., Moir, M.: Universal constructions for large objects. In: Proceedings of the 9th International Workshop on Distributed Algorithms, pp. 168–182 (1995)
Anderson, J., Moir, M.: Universal constructions for multi-object operations. In: Proceedings of the 14th Annual ACM Symposium on Principles of Distributed Computing, pp. 184–194 (1995)
Doherty, S., Herlihy, M., Luchangco, V., Moir, M.: Bringing practical lock-free synchronization to 64-bit applications. In: Proceedings of the 23rd Annual ACM Symposium on Principles of Distributed Computing, pp. 31–39 (2004)
Israeli, A., Rappoport, L.: Disjoint-Access-Parallel implementations of strong shared-memory primitives. In: Proceedings of the 13th Annual ACM Symposium on Principles of Distributed Computing, pp. 151–160 (1994)
Jayanti, P., Petrovic, S.: Efficient wait-free implementation of multiword LL/SC variables. In: To appear in 25th International Conference on Distributed Computing Systems, ICDCS 2005 (2005)
Jayanti, P., Petrovic, S.: Efficiently implementing a large number of LL/SC variables. Technical Report TR2005-446, Dartmouth College Computer Science Department (2005)
Jayanti, P., Petrovic, S.: Efficient and practical constructions of LL/SC variables. In: Proceedings of the 22nd ACM Symposium on Principles of Distributed Computing (2003)
Luchangco, V., Moir, M., Shavit, N.: Nonblocking k-compare-single-swap. In: Proceedings of the fifteenth annual ACM symposium on Parallel algorithms and architectures, pp. 314–323 (2003)
Michael, M.: Practical lock-free and wait-free LL/SC/VL implementations using 64-bit CAS. In: Guerraoui, R. (ed.) DISC 2004. LNCS, vol. 3274, pp. 144–158. Springer, Heidelberg (2004)
Author information
Authors and Affiliations
Editor information
Editors and Affiliations
Rights and permissions
Copyright information
© 2005 Springer-Verlag Berlin Heidelberg
About this paper
Cite this paper
Jayanti, P., Petrovic, S. (2005). Efficiently Implementing LL/SC Objects Shared by an Unknown Number of Processes. In: Pal, A., Kshemkalyani, A.D., Kumar, R., Gupta, A. (eds) Distributed Computing – IWDC 2005. IWDC 2005. Lecture Notes in Computer Science, vol 3741. Springer, Berlin, Heidelberg. https://doi.org/10.1007/11603771_5
Download citation
DOI: https://doi.org/10.1007/11603771_5
Publisher Name: Springer, Berlin, Heidelberg
Print ISBN: 978-3-540-30959-8
Online ISBN: 978-3-540-32428-7
eBook Packages: Computer ScienceComputer Science (R0)