A Complete Axiomatization of Real-Time Processes

Once strictly the province of assembly-language programmers, real-time computing has developed into an area of important theoretical interest. Real-time computing incorporates all of the theoretical problems encountered in concurrent processing and introduces the additional complexity of accounting for the temporal behavior of processes. In this paper we investigate two problems in the theory of real-time processes: defining realistic semantic models and developing proof systems for real-time processes. We present here a semantic domain for real-time processes that captures the temporal constraints of concurrent programs. A partial ordering based on process containment is defined and shown to be a complete partial order on the domain. The domain is used to define the denotational semantics of a CSP-like language that incorporates pure time delay. An axiomatization of process containment is presented and shown to be complete for finite terms in this language. The axiomatization is useful for proving properties of real-time processes and deriving their temporal behavior

Bounded nondeterminism and the approximation induction principle in process algebra (extended abstract)

This paper presents a new semantics of ACPτ, the Algebra of Communicating Processes with abstraction. This leads to a term model of ACPτ which is isomorphic to the model of process graphs modulo rooted τδ-bisimulation of Baeten, Bergstra & Klop In this model, the Recursive Definition Principle (RDP), the Commutativity of Abstraction (CA) and Koomen's Fair Abstraction Rule (KFAR) are satisfied, but the Approximation Induction Principle (AIP) is not. The combination of these four principles is proven to be inconsistent, while any combination of three of them is not. In [2] a restricted version of AIP is proved valid in the graph model. This paper proposes a simpler and less restrictive version of AIP, not containing guarded recursive specifications as a parameter, which is still valid. This infinitary rule is formulated with the help of a family Bn of unary predicates, expressing bounded nondeterminism

Formally Integrating Real-Time Specification: A Research Proposal

To date, research in reasoning about timing properties of real-time programs has considered specification and implementation as separate issues. Specification uses formal methods; it abstracts out program execution, defining a specification that is independent of any machine-specific details (see [I, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14] for examples). In this manner, it describes only the high-level timing requirements of processes in the system, and dependencies between them. One then typically attempts to prove the mutual consistency of these timing constraints, or to determine whether the constraints maintain a safety property critical to system correctness. However, since the model has abstracted out machine-specific details, these correctness proofs either assume very optimistic operating environment (such as a one to one assignment of processes to processors), or make very pessimistic assumptions (such as that all interleavings of process executions are possible). Since neither of these assumptions will hold in practice, these predictions about the behavior of the system may not be accurate. The implementation level captures this operating environment: a real- time system is characterized by such things as process schedulers, devices and local clocks. However, advances here have been primarily in scheduling theory (examples of which are [15, 16]) and language design (examples of which are [15, 16, 17, 18,19,20]). Unfortunately, since formal models have not been used at this level, proofs of time-related properties cannot be made. To construct these proofs, we must show that an implementation is correct with respect to a specification; timing properties that can be shown to hold about the specification will therefore be known to hold for the implementation. We therefore need to represent the implementation formally so as to prove that the implementation satisfies the specification. The proof of satisfaction requires a well-defined formal mapping between the implementation and specification models. We therefore propose to develop an integrated bi-level approach to the problem of reasoning about timing properties of real-time programs. At the specification level, we will use the Timed Acceptances model, a logically sound and complete axiom system which we have recently developed [21]. Using this model, the effect of interaction among time dependent processes can be precisely specified and then analyzed. We will then develop a formal implementation model (similar to the specification model) which captures operational behaviors: for example, the assignment of processes to processors, assumptions about scheduling and clock synchronization, and the different treatment of execution and wait times. A mapping will then be formulated between these two layers. The bulk of our proposed work will be to formulate the implementation layer and define a mapping between it and the specification layer. We also need to continue work on the Timed Acceptances model to facilitate its use as a specification model, and to provide hooks for mappings between the two layers. The rest of this proposal is organized as follows. The next section overviews related work in formal specification models. Section 3 describes our current specification model and proposed enhancements. We also detail the proposed implementation model, and required properties of the mappings between the two models. Section 4 provides a summary of the proposed research, and a yearly plan

Modeling and analysis of concurrent systems

A survey of modeling and analysis techniques in common use for modeling and analyzing concurrent systems. The models surveyed are CSP (Communicating Sequential Processes), Path Expressions, CCS (Calculus of Communicating Systems), CIRCAL, Petri Nets, Coloured Petri Nets, Predicate-Action Nets, Numerical Petri Nets, Contour-Transition Nets, and several varieties of Timed Petri Nets. The analysis techniques are state-space analysis, temporal logic, structural analysis, and inductive analysis

An algebra of discrete event processes

This report deals with an algebraic framework for modeling and control of discrete event processes. The report consists of two parts. The first part is introductory, and consists of a tutorial survey of the theory of concurrency in the spirit of Hoare's CSP, and an examination of the suitability of such an algebraic framework for dealing with various aspects of discrete event control. To this end a new concurrency operator is introduced and it is shown how the resulting framework can be applied. It is further shown that a suitable theory that deals with the new concurrency operator must be developed. In the second part of the report the formal algebra of discrete event control is developed. At the present time the second part of the report is still an incomplete and occasionally tentative working paper