Skip to main content

Fast increment registers

  • Conference paper
  • First Online:
Distributed Algorithms (WDAG 1994)

Part of the book series: Lecture Notes in Computer Science ((LNCS,volume 857))

Included in the following conference series:

  • 135 Accesses

Abstract

We give an optimal, wait-free implementation of an increment register. An increment register is a concurrent object consisting of an integer-valued register with an increment operation that atomically increments the register and returns the previous value. We implement this register in a synchronous, message-passing model with crash failures. In our implementation, an increment operation halts in O(log c) rounds of communication, where c is the number of concurrently executing increment operations. This is the first wait-free implementation of any object that matches the Ω(log c) lower bound by Herlihy and Tuttle for wait-free implementations, and it proves that their lower bound is tight. The significance of our result is not so much the implementation itself, but what it says about lower bounds. Our result says that Ω(log c) is the best possible lower bound that applies to so many objects in so many models. The algorithm itself is interesting, however, because it is based on an optimal solution for strong renaming, a simple decision problem used by Herlihy and Tuttle to prove their lower bound.

Supported in part by NSF grant CCR-93-08103.

This is a preview of subscription content, log in via an institution to check access.

Access this chapter

Institutional subscriptions

Preview

Unable to display preview. Download preview PDF.

Unable to display preview. Download preview PDF.

References

  1. Hagit Attiya, Amotz Bar-Noy, Danny Dolev, Daphne Koller, David Peleg, and Rudiger Reischuk. Achievable cases in an asynchronous environment. In Proceedings of the 28th IEEE Symposium on Foundations of Computer Science, pages 337–346, October 1987.

    Google Scholar 

  2. Hagit Attiya, Amotz Bar-Noy, Danny Dolev, David Peleg, and Rudiger Reischuk. Renaming in an asynchronous environment. Journal of the ACM, July 1990.

    Google Scholar 

  3. James Aspnes, Maurice P. Herlihy, and Nir Shavit. Counting networks and multi-processor coordination. In Proceedings of the 23th ACM Symposium on Theory of Computing, May 1991.

    Google Scholar 

  4. Maurice Herlihy. A quorum-consensus replication method for abstract data types. ACM Transactions on Computer Systems, 4(1):32–53, February 1986.

    Article  Google Scholar 

  5. Maurice P. Herlihy. Wait-free synchronization. ACM Transactions on Programming Languages and Systems, 13(1):124–149, January 1991.

    Article  Google Scholar 

  6. Maurice Herlihy. Randomized wait-free concurrent objects. In Proceedings of the 10th Annual ACM Symposium on Principles of Distributed Computing, pages 11–22. ACM, August 1991.

    Google Scholar 

  7. Joesph Y. Halpern and Ronald Fagin. Modelling knowledge and action in distributed systems. Distributed Computing, 3(4):159–179, 1989.

    Article  Google Scholar 

  8. Joseph Y. Halpern and Yoram Moses. Knowledge and common knowledge in a distributed environment. Journal of the ACM, 37(3):549–587, July 1990.

    Article  Google Scholar 

  9. Maurice P. Herlihy and Mark R. Tuttle. Wait-free computation in messagepassing systems: Preliminary report. In Proceedings of the 9th Annual ACM Symposium on Principles of Distributed Computing, pages 347–362. ACM, August 1990.

    Google Scholar 

  10. Maurice P. Herilhy and Jeannette M. Wing. Linearizability: A correctness condition for concurrent objects. ACM Transactions on Programming Languages and Systems, 12(3):463–492, July 1990.

    Article  Google Scholar 

  11. Leslie Lamport. Time, clocks, and the ordering of events in a distributed system. Communications of the ACM, 21(7):558–564, July 1978.

    Article  Google Scholar 

  12. Leslie Lamport. How to make a multiprocessor computer that correctly executes multiprocess programs. IEEE Transactions on Computers, C-28(9):690, September 1979.

    Google Scholar 

  13. Leslie Lamport. The part-time parliament. Technical Report 49, DEC Systems Research Center, September 1989.

    Google Scholar 

  14. Yoram Moses and Mark R. Tuttle. Programming simultaneous actions using common knowledge. Algorithmica, 3(1):121–169, 1988.

    Article  MathSciNet  Google Scholar 

  15. Christos H. Papadimitriou. The serializability of concurrent database updates. Journal of the ACM, 26(4):631–653, October 1979.

    Article  Google Scholar 

  16. Fred B. Schneider. Implementing fault-tolerant services using the state machine approach: a tutorial. Technical report, Cornell University, Computer Science Department, November 1987.

    Google Scholar 

Download references

Author information

Authors and Affiliations

Authors

Editor information

Gerard Tel Paul Vitányi

Rights and permissions

Reprints and permissions

Copyright information

© 1994 Springer-Verlag Berlin Heidelberg

About this paper

Cite this paper

Chaudhuri, S., Tuttle, M.R. (1994). Fast increment registers. In: Tel, G., Vitányi, P. (eds) Distributed Algorithms. WDAG 1994. Lecture Notes in Computer Science, vol 857. Springer, Berlin, Heidelberg. https://doi.org/10.1007/BFb0020425

Download citation

  • DOI: https://doi.org/10.1007/BFb0020425

  • Published:

  • Publisher Name: Springer, Berlin, Heidelberg

  • Print ISBN: 978-3-540-58449-0

  • Online ISBN: 978-3-540-48799-9

  • eBook Packages: Springer Book Archive

Publish with us

Policies and ethics