Skip to main content
SpringerLink
Log in

A criterion for atomicity

  • Published:
Formal Aspects of Computing

Abstract

Most proof methods for reasoning about concurrent programs are based upon theinterleaving semantics of concurrent computation: a concurrent program is executed in a stepwise fashion, with only one enabled action being executed at each step. Interleaving semantics, in effect, requires that a concurrent program be executed as a nondeterministic sequential program. This is clearly an abstraction of the way in which concurrent programs are actually executed. To ensure that this is a reasonable abstraction, interleaving semantics should only be used to reason about programs with “simple” actions; we call such programs “atomic”. In this paper, we formally characterise the class of atomic programs. We adopt the criterion that a program isatomic if it can be implemented in a wait-free, serialisable manner by a primitive program. A program isprimitive if each of its actions has at most one occurrence of a shared bit, and each shared bit is read by at most one process and written by at most one process. It follows from our results that the traditionally accepted atomicity criterion, which allows each action to have at most one occurrence of a shared variable, can be relaxed, allowing programs to have more powerful actions. For example, according to our criterion, an action can read any finite number of shared variables, provided it writes no shared variable.

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

Access this article

Log in via an institution

Price excludes VAT (USA)
Tax calculation will be finalised during checkout.

Instant access to the full article PDF.

Institutional subscriptions

Similar content being viewed by others

References

  1. Afek, Y., Attiya, H., Dolev, D., Gafni, E., Merritt, M., and Shavit, N.: Atomic Snapshots of Shared Memory.Proc. Ninth Annual Symp. on Principles of Distributed Computing, pp. 1–14, 1990.

  2. Anderson, J.: Multiple-Writer Composite Registers. Technical Report TR.89.26, Department of Computer Sciences, University of Texas at Austin, September 1989.

    Google Scholar 

  3. Anderson, J.: Composite Registers,Proc. Ninth Annual Symp. on Principles of Distributed Computing, pp. 15–30, 1990.

  4. Anderson, J.:Atomicity of Concurrent Programs, Ph.D. Dissertation, Department of Computer Sciences, University of Texas at Austin, 1990.

    Google Scholar 

  5. Anderson, J. and Gouda, M.: The Virtue of Patience: Concurrent Programming With and Without Waiting. Technical Report TR.90.23, Department of Computer Sciences, University of Texas at Austin, 1990.

    Google Scholar 

  6. Anderson, J. and Grošelj, B.: Pseudo Read-Modify-Write Operations: Bounded Wait-Free Implementations.Proceedings of the Fifth International Workshop on Distributed Algorithms, Lecture Notes in Computer Science 579, Springer-Verlag, 1992.

  7. Aspens, J. and Herlihy, M.: Wait-Free Data Structures in the Asynchronous PRAM Model.Proc. Second Annual ACM Symp. on Parallel Architectures and Algorithms, July 1990.

  8. Bloom, B.: Constructing Two-Writer Atomic Registers.IEEE Transactions on Computers, 37(12), 1988, 1506–1514.

    Google Scholar 

  9. Burns, J. and Peterson, G.: Constructing Multi-Reader Atomic Values from Non-Atomic Values.Proceedings of the Sixth Annual Symposium on Principles of Distributed Computing, pp. 222–231 (1987).

  10. Burns, J. and Peterson, G.: Pure Buffers for Concurrent Reading While Writing. Technical Report GIT-ICS-87/17, School of Information and Computer Science, Georgia Institute of Technology, April 1987.

  11. Chor, B., Israeli, A. and Li, M.: On Processor Coordination Using Asynchronous Hardware.Proc. Sixth Annual Symp. on Principles of Distributed Computing, pp. 86–97, 1987.

  12. Dijkstra, E.:A Discipline of Programming, Prentice-Hall, Englewood Cliffs, NJ, 1976.

    Google Scholar 

  13. Gouda, M.: Serializable Programs, Parallelizable Assertions: A Basis for Interleaving. In:Beauty is Our Business, W.H.J. Feijen, A.J.M. van Gasteren, D. Gries and J. Misra (eds), pp. 135–140, Springer-Verlag, 1990.

  14. Herlihy, M.: Wait-Free Synchronization.ACM Transactions on Programming Languages and Systems, 13(1), 124–149, (1991).

    Google Scholar 

  15. Herlihy, M. and Wing, J.: Linearizability: A Correctness Condition for Concurrent Objects.ACM Transactions on Programming Languages and Systems, 12(3), 463–492, (1990).

    Google Scholar 

  16. Kirousis, L., Kranakis, E. and Vitanyi, P.: Atomic Multireader Register.Proc. Second Int. Workshop on Distributed Computing, Lecture Notes in Computer Science 312, pp. 278–296, Springer Verlag, 1987.

  17. Hoare, C.A.R.: Towards a Theory of Parallel Programming. In:Operating Systems Techniques, Hoare and Perott (eds), Academic Press, New York, 1972.

    Google Scholar 

  18. Kruskal, C., Rudolph, L. and Snir, M.: Efficient Synchronization on Multiprocessors with Shared Memory.ACM Transactions on Programming Languages and Systems, 10(4), 579–601, (1988).

    Google Scholar 

  19. Lamport, L.: On Interprocess Communication, Parts I and II.Distributed Computing, 1, 77–101, (1986).

    Google Scholar 

  20. Lamport, L.:win andsin: Predicate Transformers for Concurrency.ACM Transactions on Programming Languages and Systems, 12(3), 396–428, (1990).

    Google Scholar 

  21. Lamport, L. and Schneider, F.: The Hoare Logic of CSP, and All That.A CM Transactions on Programming Languages and Systems, 6(2), 281–296, (1984).

    Google Scholar 

  22. Li, M., Tromp, J. and Vitanyi, P.: How to Construct Wait-Free Variables.Proceedings of International Colloquium on Automata, Languages, and Programming, Lecture Notes in Computer Science 372, pp. 488–505, Springer-Verlag, 1989.

  23. Manna, Z. and Pnueli, A.: Adequate Proof Principles for Invariance and Liveness Properities of Concurrent Programs.Science of Computer Programming, 4, 257–289, (1984).

    Google Scholar 

  24. Misra, J.: Axioms for Memory Access in Asynchronous Hardware Systems.ACM Transactions on Programming Languages and Systems, 8(1), 142–153, (1986).

    Google Scholar 

  25. Newman-Wolfe, R.: A Protocol for Wait-Free, Atomic, Multi-Reader Shared Variables.Proceedings of the Sixth Annual Symposium on Principles of Distributed Computing, pp. 232–248 (1987).

  26. Owicki, S. and Gries, D.: An Axiomatic Proof Technique for Parallel Programs I.Acta Informatica, 6, 319–340, (1976).

    Google Scholar 

  27. Peterson, G. and Burns, J.: Concurrent Reading While Writing II: The Multi-Writer Case.Proceedings of the 28th Annual Symposium on Foundations of Computer Science, 1987.

  28. Singh, A., Anderson, J. and Gouda, M.: The Elusive Atomic Register, Revisited.Proc. Sixth Annual Symp. on Principles of Distributed Computing, pp. 206–221, 1987.

  29. Tromp, J.:Proc. of the Third International Workshop on Distributed Algorithms, Lecture Notes in Computer Science 392, pp 292–302, Springer-Verlag, 1989.

  30. Vitanyi, P. and Awerbuch, B.: Atomic Shared Register Access by Asynchronous Hardware.Proceedings of the 27th IEEE Symposium on the Foundations of Computer Science, 1986, pp. 233–243.

Download references

Author information

Authors and Affiliations

  1. Department of Computer Science, The University of Maryland at College Park, 20742-3255, Maryland, MD, USA

    James H. Anderson

  2. Department of Computer Sciences, The University of Texas at Austin, Texas, USA

    Mohamed G. Gouda

Authors
  1. James H. Anderson
    View author publications

    You can also search for this author in PubMed Google Scholar

  2. Mohamed G. Gouda
    View author publications

    You can also search for this author in PubMed Google Scholar

Additional information

Work supported, in part, at the University of Texas at Austin by Office of Naval Research Contract N00014-89-J-1913, and at the University of Maryland by an award from the University of Maryland General Research Board.

Work supported, in part, by Office of Naval Research Contract N00014-89-J-1913.

Rights and permissions

Reprints and permissions

About this article

Cite this article

Anderson, J.H., Gouda, M.G. A criterion for atomicity. Formal Aspects of Computing 4, 273–298 (1992). https://doi.org/10.1007/BF01212305

Download citation

  • Received:

  • Accepted:

  • Issue Date:

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

Keywords

Search

Navigation