Relating Communicating Processes with Different Interfaces

We present here an implementation relation intended to formalise the notion that a system built of communicating processes is an acceptable implementation of another base, or target, system in the event that the two systems have different interfaces. Such a treatment has clear applicability in the software development process, where (the interface of) an implementation component may be expressed at a different level of abstraction to (the interface of) the relevant specification component.Technically, processes are formalised using Hoare's CSP language, with its standard failures-divergences model. The implementation relation is formulated in terms of failures and divergences of the implementation and target processes. Interface difference is modelled by endowing the implementation relation with parameters called extraction patterns. These are intended to interpret implementation behaviour as target behaviour, and suitably constrain the former in connection to well-formedness and deadlock properties.We extend the results of our previous work and replace implementation relations previously presented by a single, improved scheme. We also remove all the restrictions previously placed upon target processes. Two basic kinds of results are obtained: realisability and compositionality. The latter means that a target composed of several connected systems may be implemented by connecting their respective implementations. The former means that, if target and implementation in fact have the same interface, then the implementation relation they should satisfy collapses into standard implementation pre-order.We also show how to represent processes and extraction patterns in a manner amenable to computer implementation, and detail a graph-theoretic restatement of the conditions defining the implementation relation, from which algorithms for their automatic verification are easily derived.

[1]  Leslie Lamport,et al.  The Implementation of Reliable Distributed Multiprocess Systems , 1978, Comput. Networks.

[2]  Matthew Hennessy,et al.  Algebraic theory of processes , 1988, MIT Press series in the foundations of computing.

[3]  Cliff B. Jones,et al.  Enhancing the tractability of rely/guarantee specifications in the development of interfering operations , 2000, Proof, Language, and Interaction.

[4]  Arend Rensink,et al.  Vertical Implementation , 2001, Inf. Comput..

[5]  Maciej Koutny,et al.  Compositional Development in the Event of Interface Difference , 2002 .

[6]  Bengt Jonsson,et al.  Refining Interfaces of Communicating Systems , 1991, TAPSOFT, Vol.2.

[7]  Bengt Jonsson,et al.  Compositional specification and verification of distributed systems , 1994, TOPL.

[8]  Robin Milner,et al.  Communication and concurrency , 1989, PHI Series in computer science.

[9]  Luigi V. Mancini,et al.  Two implementation relations and the correctness of communicating replicated processes , 1997, Formal Aspects of Computing.

[10]  Andrew William Roscoe,et al.  The Theory and Practice of Concurrency , 1997 .

[11]  Jozef Hooman,et al.  Trace-Based Compositional Reasoning about Fault Tolerant Systems , 1993, PARLE.

[12]  C. A. R. Hoare,et al.  Communicating sequential processes , 1978, CACM.

[13]  Maciej Koutny,et al.  Behaviour Abstraction for Communicating Sequential Processes , 2001, Fundam. Informaticae.

[14]  Luigi V. Mancini,et al.  Two Implementation Relations and the Correctness of Communicated Replicated Processing. Formal Aspects of Computing 9 , 1997 .

[15]  Martín Abadi,et al.  The existence of refinement mappings , 1988, [1988] Proceedings. Third Annual Information Symposium on Logic in Computer Science.

[16]  Walter Murray Wonham,et al.  Hierarchical control of discrete-event systems , 1996, Discret. Event Dyn. Syst..

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

[18]  Nancy A. Lynch,et al.  Hierarchical correctness proofs for distributed algorithms , 1987, PODC '87.

[19]  Maciej Koutny,et al.  Verifying Implementation Relations , 2001, FME.

[20]  Maciej Koutny,et al.  Implementing communicating processes in the event of interface difference , 2001, Proceedings Second International Conference on Application of Concurrency to System Design.

[21]  Luca Aceto,et al.  Towards Action-Refinement in Process Algebras , 1993, Inf. Comput..

[22]  W. M. Wonham,et al.  On the consistency of hierarchical supervision in discrete-event systems , 1990 .

[23]  Luigi V. Mancini,et al.  Towards a Theory of Replicated Processing , 1988, FTRTFT.