Bounds on the costs of register implementations

  • Soma Chaudhuri
  • Jennifer Welch
Conference paper
Part of the Lecture Notes in Computer Science book series (LNCS, volume 486)

Abstract

A fundamental aspect of any concurrent system is how processes communicate with each other. Ultimately, all communication involves concurrent reads and writes of shared memory cells, or registers. The stronger the guarantees provided by a register, the more useful it is to the user, but the harder it may be to implement in practice. Thus it is of interest to determine which types of registers can implement which other types of registers. The types of registers studied in this paper are safe vs. regular, 1-reader vs. n-readers, and binary vs. k-ary. Algorithms for various implementations have been previously developed. These have, for the most part, concentrated on the relative computability between different types of registers. In contrast, this paper studies the relative complexity of such algorithms, by considering the costs incurred when implementing one type of register (the logical register) with registers of another type (physical registers). The cost measures considered are the number of physical registers and the number of reads and writes on the physical registers required to implement the logical register. Bounds on the number of physical operations can be easily converted to provide time bounds for the logical operations. Tight bounds are obtained on the cost measures in many cases, and interesting trade-offs between the cost measures are identified. The lower bounds are shown using information-theoretic techniques. Two new algorithms are presented that improve on the costs of previously known algorithms: the hypercube algorithm implements a k-ary safe register out of binary safe registers, requiring only one physical write per logical write; and the tree algorithm implements a k-ary regular register out of binary regular registers, requiring only log k physical operations per logical operation. Both algorithms use novel combinatorial techniques.

Preview

Unable to display preview. Download preview PDF.

Unable to display preview. Download preview PDF.

References

  1. [Blo87]
    Bard Bloom. Constructing Two-Writer Atomic Registers. In Proceedings of the Sixth Annual ACM SIGACT-SIGOPS Symposium on Principles of Distributed Computing, pages 249–259, August 1987.Google Scholar
  2. [BP87]
    James E. Burns and Gary L. Peterson. Constructing Multi-Reader Atomic Values from Non-Atomic Values. In Proceedings of the Sixth Annual ACM SIGACT-SIGOPS Symposium on Principles of Distributed Computing, pages 222–231, August 1987.Google Scholar
  3. [CW90]
    Soma Chaudhuri and Jennifer L. Welch. Bounds on the Costs of Register Implementations. Technical Report TR90-025, University of North Carolina, Chapel Hill, June 1990.Google Scholar
  4. [KvL90]
    Goos Kant and Jan van Leeuwen. The File Distribution Problem for Processor Networks. In Lecture Notes in Computer Science 447: Proceedings of the Second Scandinavian Workshop on Algorithm Theory, pages 48–59. Springer-Verlag, July 1990.Google Scholar
  5. [Lam86]
    Leslie Lamport. On Interprocess Communication. Distributed Computing, 1(1):86–101, 1986.Google Scholar
  6. [LG89]
    Nancy A. Lynch and Kenneth J. Goldman. Distributed Algorithms: Lecture Notes for 6.852. Research Seminar Series MIT/LCS/RSS 5, Massachusetts Institute of Technology, May 1989.Google Scholar
  7. [LTV90]
    Ming Li, John Tromp, and Paul M. B. Vitanyi. How to Share Concurrent Wait-Free Variables. submitted for publication, June 1990.Google Scholar
  8. [NW87]
    Richard Newman-Wolfe. A Protocol for Wait-Free, Atomic, Multi-Reader Shared Variables. In Proceedings of the Sixth Annual ACM SIGACT-SIGOPS Symposium on Principles of Distributed Computing, pages 232–248, August 1987.Google Scholar
  9. [Pet83]
    Gary Peterson. Concurrent Reading While Writing. ACM Transactions on Programming Languages and Systems, 5(1):46–55, 1983.Google Scholar
  10. [SAG87]
    Ambuj K. Singh, James H. Anderson, and Mohamed G. Gouda. The Elusive Atomic Register Revisited. In Proceedings of the Sixth Annual ACM SIGACT-SIGOPS Symposium on Principles of Distributed Computing, pages 206–221, August 1987.Google Scholar
  11. [Tro89]
    J. T. Tromp. How to Construct an Atomic Variable. Technical Report CS-R8939, Centre for Mathematics and Computer Science, Amsterdam, October 1989.Google Scholar
  12. [Tya88]
    A. Tyagi. The Role of Energy in VLSI Computations. PhD thesis, Department of Computer Science, University of Washington, Seattle, 1988. Available as UWCS Technical Report Number 88-06-05.Google Scholar
  13. [VA86]
    Paul M. B. Vitanyi and Baruch Awerbuch. Atomic Shared Register Access by Asynchronous Hardware. In Proceedings of the Twenty-seventh Annual IEEE Symposium on Foundations of Computer Science, pages 233–243, October 1986.Google Scholar
  14. [Vid88]
    K. Vidyasankar. Converting Lamport's Regular Register to Atomic Register. Information Processing Letters, 28:287–290, 1988.Google Scholar

Copyright information

© Springer-Verlag 1991

Authors and Affiliations

  • Soma Chaudhuri
    • 1
  • Jennifer Welch
    • 2
  1. 1.Department of Computer Science and EngineeringUniversity of WashingtonSeattle
  2. 2.Department of Computer ScienceUniversity of North CarolinaChapel Hill

Personalised recommendations