An Object-Based Design Method for Concurrent Programs

The property of a (formal) development method which gives the development process the potential for productivity is compositionality. Interference is what makes it difficult to find compositional development methods for concurrent systems. This paper is intended to contribute to tractable development methods for concurrent programs. In particular it explores ways in which object-based language concepts can be used to provide a compositional development method for concurrent programs. This text summarizes results from three draft papers. It firstly shows how object-based concepts can be used to provide a designer with control over interference and proposes a transformational style of development (for systems with limited interference) in which concurrency is introduced only in the final stages of design. The essential idea here is to show that certain object graphs limit interference. Secondly, the paper shows how a suitable logic can be used to reason about those systems where interference plays an essential role. Here again, concepts are used in the design notation which are taken from object-oriented languages since they offer control of granularity and way of pinpointing interference. Thirdly, the paper outlines the semantics of the design notation mapping its constructs to Milner’s π-calculus. ∗Copyright 1992. All rights reserved. Reproduction of all or part of this work is permitted for educational or research purposes on condition that (1) this copyright notice is included, (2) proper attribution to the author or authors is made and (3) no commercial gain is involved. Technical Reports issued by the Department of Computer Science, Manchester University, are available by anonymous ftp from m1.cs.man.ac.uk (130.88.13.4) in the directory /pub/TR. The files are stored as PostScript, in compressed form, with the report number as filename. Alternatively, reports are available by post from The Computer Library, Department of Computer Science, The University, Oxford Road, Manchester M13 9PL, U.K.

[1]  Ernst-Rüdiger Olderog,et al.  Using Transformation to Verify Parallel Programs , 1989, Algebraic Methods.

[2]  K. Mani Chandy,et al.  Parallel program design - a foundation , 1988 .

[3]  Eugene W. Stark.  Proving Entailment Between Conceptual State Specifications , 1988, Theor. Comput. Sci..

[4]  Cliff B. Jones,et al.  Interference Revisited , 1990, Z User Workshop.

[5]  Xu Qiwen,et al.  A theory of state-based parallel programming , 1992 .

[6]  Christian Lengauer,et al.  A Methodology for Programming with Concurrency: An Informal Presentation , 1982, Sci. Comput. Program..

[7]  Mario Tokoro,et al.  An Object Calculus for Asynchronous Communication , 1991, ECOOP.

[8]  Manfred Broy,et al.  On bounded buffers: modularity, robustness, and reliability in reactive systems , 1990 .

[9]  Cliff B. Jones,et al.  Specification and Design of (Parallel) Programs , 1983, IFIP Congress.

[10]  Frits W. Vaandrager,et al.  Process algebra semantics of POOL , 1992 .

[11]  Leslie Lamport,et al.  The temporal logic of actions , 1994, TOPL.

[12]  Ole Lehrmann Madsen,et al.  Object-oriented programming in the BETA programming language , 1993 .

[13]  Eugene W. Stark,et al.  A Proof Technique for Rely/Guarantee Properties , 1985, FSTTCS.

[14]  Susan S. Owicki,et al.  Axiomatic Proof Techniques for Parallel Programs , 1975, Outstanding Dissertations in the Computer Sciences.

[15]  Michael W. Godfrey,et al.  VDM '91 Formal Software Development Methods , 1991, Lecture Notes in Computer Science.

[16]  Howard Barringer,et al.  Hierarchical Development of Cncurrent Systems in a Temporal Logic Framework , 1984, Seminar on Concurrency.

[17]  P.H.M. America,et al.  A parallel object-oriented language: design and semantic foundations , 1989 .

[18]  Colin Stirling,et al.  A Generalization of Owicki-Gries's Hoare Logic for a Concurrent while Language , 1988, Theor. Comput. Sci..

[19]  Chak-Kuen Wong,et al.  A New Permutation Algorithm for Bubble Memories , 1980, Information Processing Letters.

[20]  J Job Zwiers.  Compositionality, Concurrency, and Partial Correctness: Proof Theories for Networks of Processes and Their Relationship , 1989 .

[21]  Albert R. Meyer,et al.  The international conference on theoretical aspects of computer science , 1993 .

[22]  Cliff B. Jones,et al.  Developing methods for computer programs including a notion of interference , 1981 .

[23]  Cliff B. Jones,et al.  Systematic software development using VDM , 1986, Prentice Hall International Series in Computer Science.

[24]  Cliff B. Jones,et al.  Tentative steps toward a development method for interfering programs , 1983, TOPL.

[25]  Peter A. Lindsay,et al.  mural: A Formal Development Support System , 1991, Springer London.

[26]  Greg Nelson,et al.  Systems programming in modula-3 , 1991 .

[27]  Jim Woodcock,et al.  Using VDM with Rely and Guarantee-Conditions - Experiences from a Real Project , 1988, VDM Europe.

[28]  John Sargeant.  UFO - United Functions and Objects: Draft Language Description , 1992 .

[29]  Robin Milner,et al.  Functions as processes , 1990, Mathematical Structures in Computer Science.

[30]  米沢 明憲.  ABCL : an object-oriented concurrent system , 1990 .

[31]  Pierre America,et al.  A proof theory for a sequential version of POOL , 1990 .

[32]  Pierre America,et al.  Formal Techniques for Parallel Object-Oriented Languages , 1991, CONCUR.

[33]  Stephen J. Garland,et al.  Larch: Languages and Tools for Formal Specification , 1993, Texts and Monographs in Computer Science.

[34]  Mario Wolczko.  Semantics of object-oriented languages , 1988 .

[35]  Mario Tokoro,et al.  A small calculus for concurrent objects , 1991, OOPSLA/ECOOP '90.

[36]  C. A. R. Hoare,et al.  The Laws of Occam Programming , 1988, Theor. Comput. Sci..

[37]  Hans Toetenel,et al.  VDM'91 Formal Software Development Methods , 1991, Lecture Notes in Computer Science.

[38]  Jan Friso Groote,et al.  Proceedings of the 2nd International Conference on Concurrency Theory , 1991 .

[39]  Ketil Stølen,et al.  An Attempt to Reason about Shared-State Concurrency in the Style of VDM , 1991, VDM Europe.

[40]  Robin Bloomfield,et al.  VDM '88 VDM — The Way Ahead , 1988, Lecture Notes in Computer Science.

[41]  Ketil Stølen,et al.  A Method for the Development of Totally Correct Shared-State Parallel Programs , 1991, CONCUR.

[42]  John Dawes,et al.  The VDM-SL Reference Guide , 1991 .

[43]  Robin Milner,et al.  Modal Logics for Mobile Processes , 1991, Theor. Comput. Sci..

[44]  J. Baeten.  Applications of process algebra , 1990 .

[45]  W-P de Roever,et al.  The quest for compositionality - a survey of assertion - based proof systems for concurrent programs. Part 1 ; concurrency based on shared variables , 1985 .

[46]  Frank S. de Boer,et al.  A Proof System for Process Creation , 1990, Programming Concepts and Methods.

[47]  Jan A. Bergstra,et al.  Algebraic Methods II: Theory, Tools and Applications , 1991, Lecture Notes in Computer Science.

[48]  Colin Stirling.  A Compositional Reformulation of Owicki-Gries's Partial Correctness Logic for a Concurrent While Language , 1986, ICALP.

[49]  Pierre America,et al.  A Layered Semantics for a Parallel Object-Oriented Language , 1990, REX Workshop.

[50]  P. J. Landin,et al.  The next 700 programming languages , 1966, CACM.

[51]  Robin Milner,et al.  The Polyadic π-Calculus: a Tutorial , 1993 .

[52]  C. A. R. Hoare,et al.  Laws of programming , 1987, CACM.

[53]  Mannes Poel,et al.  Action Systems and Action Refinement in the Development of Parallel Systems - An Algebraic Approach , 1991, CONCUR.