True Concurrency Model Research Articles

Mechanized Theory of Event Structures: A Case of Parallel Register Machine

The true concurrency models, and in particular event structures, have been introduced in the 1980s as an alternative to operational interleaving semantics of concurrency, and nowadays they are regaining popularity. Event structures represent the causal dependency and conflict between the individual atomic actions of the system directly. This property leads to a more compact and concise representation of semantics. In this work-in-progress report, we present a theory of event structures mechanized in the COQ proof assistant and demonstrate how it can be applied to define certified executable semantics of a simple parallel register machine with shared memory.

Non-interference in Partial Order Models

Non-interference (NI) is a property of systems stating that confidential actions should not cause effects observable by unauthorized users. Several variants of NI have been studied for many types of models but rarely for true concurrency or unbounded models. This work investigates NI for High-level Message Sequence Charts (HMSCs), a scenario language for the description of distributed systems, based on composition of partial orders. We first propose a general definition of security properties in terms of equivalence among observations of behaviors. Observations are naturally captured by partial order automata, a formalism that generalizes HMSCs and permits assembling partial orders. We show that equivalence or inclusion properties for HMSCs (and hence for partial order automata) are undecidable, which means in particular that NI is undecidable for HMSCs. We hence consider decidable subclasses of partial order automata and HMSCs. Finally, we define weaker local properties, describing situations where a system is attacked by a single agent, and show that local NI is decidable. We then refine local NI to a finer notion of causal NI that emphasizes causal dependencies between confidential actions and observations and extend it to causal NI with (selective) declassification of confidential events. Checking whether a system satisfies local and causal NI and their declassified variants are PSPACE-complete problems.

Solving preemptive job-shop scheduling problems using a true concurrency model

A true concurrency model called stopwatch durational action timed automata (S-DATA) is proposed to model preemptive timed concurrent systems. We demonstrate its usefulness in tackling the preemptive job-shop scheduling problem (PJSSP). This yields a compact reachability tree representing the possible schedules such that the durations and preemptions of the scheduled actions are dynamically managed. Different techniques are demonstrated to reduce the space search over such reachability tree, preserving the optimal schedules of the problem. The efficiency of approach is tested on a number of well-known benchmark problems and compared with the best method of scheduling in common use.

Logic Unification of Behavioral Equivalences of Timed Event Structures

We propose a uniform logic characterization of some timed extensions of partial order based equivalences (pomset trace equivalence, testing equivalence, history preserving bisimulation, and hereditary history preserving bisimulation) in the setting of a true concurrency model timed event structures.

Model‐based testing for concurrent systems with labelled event structures

SUMMARYWe propose a theoretical testing framework and a test generation algorithm for concurrent systems specified with true‐concurrency models, such as Petri nets or networks of automata. The semantic model of computation of such formalisms is labelled event structures, which allow to represent concurrency explicitly. We introduce the notions of strong and weak concurrency: strongly concurrent events must be concurrent in the implementation, while weakly concurrent ones may eventually be ordered. The ioco type conformance relations for sequential systems rely on the observation of sequences of actions and blockings; thus, they are not capable of capturing and exploiting concurrency of non‐sequential behaviours. We propose an extension of ioco for labelled event structures, named co‐ioco, allowing to deal with strong and weak concurrency. We extend the notions of test cases and test execution to labelled event structures and give a test generation algorithm building a complete test suite for co‐ioco. Copyright © 2014 John Wiley & Sons, Ltd.

Event Identifier Logic

In this paper we introduce Event Identifier Logic (EIL), which extends Hennessy–Milner logic by the addition of:(1)reverse as well as forward modalities; and(2)identifiers to keep track of events.We show that this logic corresponds to hereditary history-preserving (HH) bisimulation equivalence within a particular true-concurrency model, namely, stable configuration structures. We also show how natural sublogics of EIL correspond to coarser equivalences. In particular, we provide logical characterisations of weak-history- preserving (WH) and history-preserving (H) bisimulation. Logics corresponding to HH and H bisimulation have been given previously, but none, as far as we are aware, corresponding to WH bisimulation (when autoconcurrency is allowed). We also present characteristic formulas that characterise individual structures with respect to history-preserving equivalences.

A Logic with Reverse Modalities for History-preserving Bisimulations

We introduce event identifier logic (EIL) which extends Hennessy-Milner logic by the addition of (1) reverse as well as forward modalities, and (2) identifiers to keep track of events. We show that this logic corresponds to hereditary history-preserving (HH) bisimulation equivalence within a particular true-concurrency model, namely stable configuration structures. We furthermore show how natural sublogics of EIL correspond to coarser equivalences. In particular we provide logical characterisations of weak history-preserving (WH) and history-preserving (H) bisimulation. Logics corresponding to HH and H bisimulation have been given previously, but not to WH bisimulation (when autoconcurrency is allowed), as far as we are aware. We also present characteristic formulas which characterise individual structures with respect to history-preserving equivalences.

Synchronous Kleene algebra

The work presented here investigates the combination of Kleene algebra with the synchrony model of concurrency from Milner’s SCCS calculus. The resulting algebraic structure is called synchronous Kleene algebra. Models are given in terms of sets of synchronous strings and finite automata accepting synchronous strings. The extension of synchronous Kleene algebra with Boolean tests is presented together with models on sets of guarded synchronous strings and the associated automata on guarded synchronous strings. Completeness w.r.t. the standard interpretations is given for each of the two new formalisms. Decidability follows from completeness. Kleene algebra with synchrony should be included in the class of true concurrency models. In this direction, a comparison with Mazurkiewicz traces is made which yields their incomparability with synchronous Kleene algebras (one cannot simulate the other). On the other hand, we isolate a class of pomsets which captures exactly synchronous Kleene algebras. We present an application to Hoare-like reasoning about parallel programs in the style of synchrony.

Typed event structures and the linear [formula omitted]-calculus

We propose a typing system for the true concurrent model of event structures that guarantees the interesting behavioural properties known as conflict freeness and confusion freeness. Conflict freeness is the true concurrent version of the notion of confluence. A system is confusion free if nondeterministic choices are localised and do not depend on the scheduling of independent components. Ours is the first typing system to control behaviour in a true concurrent model. To demonstrate its applicability, we show that typed event structures give a semantics of linearly typed version of the π -calculi with internal mobility. The semantics we provide is the first event structure semantics of the π -calculus and generalises Winskel’s original event structure semantics of CCS.

An action refinement operator for E-LOTOS with true concurrency

Action refinement is an important operation in the hierarchical synthesis of concurrent systems. We propose an action refinement operator for E-LOTOS, a standard process-algebraic language for formal specification of real-time, concurrent and reactive systems. As the first step towards giving E-LOTOS a multitude of refinement operators supporting a variety of strategies for event relationship inheritance, we propose an operator which seems both useful and simple to implement. When the operator is applied to an E-LOTOS process, it modifies its enhanced event structure, i.e. its recently defined true concurrency model. The operator allows multiple alternative implementations even for urgent events and properly reflects the fact that gate actions of E-LOTOS processes are in the general case abstractions of distributed data generation procedures.

Typed Event Structures and the π-Calculus: Extended Abstract

We propose a typing system for the true concurrent model of event structures that guarantees the interesting behavioural properties known as conflict freeness and confusion freeness. Conflict freeness is the true concurrent version of the notion of confluence. A system is confusion free if nondeterministic choices are localised and do not depend on the scheduling of independent components. Ours is the first typing system to control behaviour in a true concurrent model. To demonstrate its applicability, we show that typed event structures give a semantics of linearly typed version of the π-calculi with internal mobility. The semantics we provide is the first event structure semantics of the π-calculus and generalises Winskel's original event structure semantics of CCS.

Synthesis of distributed testers from true-concurrency models of reactive systems

Automatic synthesis of test cases for conformance testing has been principally developed with the objective of generating sequential test cases. In the distributed system context, it is worth extending the synthesis techniques to the generation of multiple testers. We base our work on our experience in using model-checking techniques, as successfully implemented in the Test Generation using the Verification tool. Continuing the works of Ulrich and König, we propose to use a true-concurrency model based on graph unfolding. The article presents the principles of a complete chain of synthesis, starting from the definition of test purposes and ending with a projection onto a set of testers.

True Concurrency in Models of Asynchronous Circuit Behavior

In the study of asynchronous designs most authors use the interleaving model of concurrency when describing the behavior of a networks this is usually done for simplicity. The interleaving model assumes the behavior of an asynchronous circuit can be adequately represented by allowing only one signal to change at a time. In contrast to this, true concurrency models allow an arbitrary number of simultaneous signal changes. It seems that little effort has been made to determine what effect the choice of model may have on the analysis of a network. In this paper, we attempt to discover the circumstances under which the assumption of single signal changes can be made without affecting the results of circuit analysis. We prove, in a formal network model, that, in the context of delay-insensitivity and semi-modularity, the single change assumption is valid. We also prove that the same is true for a different definition of delay-insensitivity, restricted to deterministic behaviors. Consequently, in these cases, the more complicated true concurrency analysis is not required.

Refinement of Actions in a Real-Time Process Algebra with a True Concurrency Model

In this paper, we develop techniques of action refinement in a real-time process algebra that allows urgent interactions to model timeout. Semantic counterpart is carried out in a real-time non-interleaving causality based setting, timed bundle event structures. We show that our refinement notions have the following nice properties: the observable behaviour of the refined system can be inferred compositionally from the observable behaviour of the original system and from the observable behaviour of the processes substituted for the actions; the timed extensions of observational pomset trace equivalence and observational history preserving bisimulation equivalence are both congruences under our refinement; and the syntactic and semantic refinements coincide up to the aforementioned equivalence relations with respect to a cpo-based denotational semantics.

A true concurrency semantics for parallel programs

The paper shows, how the true concurrency model for concurrent systems, so-called directed, acyclic, arc-labelled graphs, and propositional Concurrent Temporal Logic, that have been developed for the specification and verification of elementary net systems, can be adapted to give a true concurrency semantics to shared variables programs, and to write first-order specifications of the programs, so that also concurrency can be specified.

A true concurrency model of CCS semantics

Degano et al. (1989) introduced AC/E systems (augmented C/E systems) to give a true concurrency semantics to CCS. But the true concurrency was not complete. There was no true concurrency for recursive agents (like < x>. e 1| e 2) and nondeterminant agents (like e 1| e 2+ e 3| e 4). Also the concept of bisimulation has not been transplanted to AC/E systems. This paper defines a complete true concurrency model of CCS by exploiting the potential concurrency of any CCS agent to its full strength. It introduces a kind of multilayered Petri nets, called NP/R nets, to define the processes on AC/E systems. We also introduced the notion of bisimulation of groups of NP/R nets and proved that this bisimulation relation can determine the CCS bisimulation uniquely.

L.0: a truly concurrent executable temporal logic language for protocols

The semantics L.0, a programming language designed for the specification and simulation of protocols that assumes a true concurrency model, is given in terms of predicate linear temporal logic, and the restricted universe of models assumed in L.0 programs is defined. The execution algorithm for L.0 constructs a model in this universe. The restricted subset of temporal logic exploited permits a nonbacktracking execution algorithm. Fundamental to the semantics of L.0 is a frame assumption, which generalizes the frame assumption of standard imperative programming, and which eases specification of protocols. The data domain assumed in L.0 programs is sets of trees with labeled edges, and the state predicates permitted include existence and nonexistence predicates, as well as the more traditional assignment and equality predicates. These choices for data domain and predicates permit convenient specification of the hierarchical message structure often assumed in telecommunications protocols, for in such message structures, the existence or nonexistence of parts of the message hierarchy is determined by logical properties of the rest of the message hierarchy. A small portion of the logical layer specification of Futurebus+ is taken as the main example in this study. >