We investigate classes of systems based on different interaction patterns with the aim of achieving distributability. As our system model we use Petri nets. In Petri nets, an inherent concept of simultaneity is built in, since when a transition has more than one preplace, it can be crucial that tokens are removed instantaneously. When modelling a system which is intended to be implemented in a distributed way by a Petri net, this built-in concept of synchronous interaction may be problematic. To investigate this we consider asynchronous implementations of nets, in which removing tokens from places can no longer be considered as instantaneous. We model this by inserting silent (unobservable) transitions between transitions and some of their preplaces. We investigate three such implementations, differing in the selection of preplaces of a transition from which the removal of a token is considered time consuming, and the possibility of collecting the tokens in a given order. We investigate the effect of these different transformations of instantaneous interaction into asynchronous interaction patterns by comparing the behaviours of nets before and after insertion of the silent transitions. We exhibit for which classes of Petri nets we obtain equivalent behaviour with respect to failures equivalence. It turns out that the resulting hierarchy of Petri net classes can be described by semi-structural properties. For two of the classes we obtain precise characterisations; for the remaining class we obtain lower and upper bounds. We briefly comment on possible applications of our results to Message Sequence Charts.
Deep Dive into Symmetric and Asymmetric Asynchronous Interaction.
We investigate classes of systems based on different interaction patterns with the aim of achieving distributability. As our system model we use Petri nets. In Petri nets, an inherent concept of simultaneity is built in, since when a transition has more than one preplace, it can be crucial that tokens are removed instantaneously. When modelling a system which is intended to be implemented in a distributed way by a Petri net, this built-in concept of synchronous interaction may be problematic. To investigate this we consider asynchronous implementations of nets, in which removing tokens from places can no longer be considered as instantaneous. We model this by inserting silent (unobservable) transitions between transitions and some of their preplaces. We investigate three such implementations, differing in the selection of preplaces of a transition from which the removal of a token is considered time consuming, and the possibility of collecting the tokens in a given order. We investig
In this paper, we investigate classes of systems based on different asynchronous interaction patterns with the aim of achieving distributability, i.e. the possibility to execute a system on spatially distributed locations, which do not share a common clock. As our system model we use Petri nets. The main reason for this choice is the detailed way in which a Petri net represents a concurrent system, including the interaction between the components it may consist of. In an interleaving based model of concurrency such as labelled transition systems modulo bisimulation semantics, a system representation as such cannot be said to display synchronous or asynchronous interaction; at best these are properties of composition operators, or communication primitives, defined in terms of such a model. A Petri net on the other hand displays enough detail of a concurrent system to make the presence of synchronous communication discernible. This makes it possible to study asynchronous communication without digressing to the realm of composition operators. In a Petri net, a transition interacts with its preplaces by consuming tokens. An inherent concept of simultaneity is built in, since when a transition has more than one preplace, it can be crucial that tokens are removed instantaneously, depending on the surrounding structure or-more elaborately-the behaviour of the net.
When modelling a distributed system by a Petri net, this built-in concept of synchronous interaction may become problematic. Assume a transition t on a location l models an activity involving another location l ′ , for example by receiving a message. This can be modelled by a preplace s of t such that s and t are situated in different locations. We assume that taking a token can in this situation not be considered as instantaneous; rather the interaction between s and t takes time. We model this effect by inserting silent (unobservable) transitions between transitions and their preplaces. We call the effect of such a transformation of a net N an asynchronous implementation of N .
An example of such an implementation is shown in Figure 1. Note that a can be disabled in the implementation before any visible behaviour has taken place. This difference will cause non-equivalence between the original and the implementation under branching time equivalences.
Our asynchronous implementation allows a token to start its journey from a place to a transition even when not all preplaces of the transition contain a token. This design decision is motivated by the observation that it is fundamentally impossible to check in an asynchronous way whether all preplaces of a transition are marked-it could be that a token moves back and forth between two such places.
We investigate different interaction patterns for the asynchronous implementation of nets. The simplest pattern (full asynchrony) assumes that every removal of a token from a place is time consuming. For the next pattern (symmetric asynchrony), tokens are only removed slowly when they are consumed by a backward branched transition, hence where the concept of simultaneous removal actually occurs. Finally we consider a more intricate pattern by allowing to remove tokens from preplaces of backward branched transitions asynchronously in sequence (asymmetric asynchrony).
Given a choice of interaction pattern, we call a net N asynchronous when there is no essential behavioural difference between N and its asynchronous implementation I(N ). In order to formally define this concept, we wish to compare the behaviours of N and I(N ) using a semantic equivalence that fully preserves branching time, causality and their interplay, whilst of course abstracting from silent transitions. By choosing the most discriminating equivalence possible, we obtain the smallest possible class of asynchronous nets, thus excluding nets that might be classified as asynchronous merely because a less discriminating equivalence would fail to see the differences between such a net and its asynchronous implementation. To simplify the exposition, here we merely compare the behaviours of N and I(N ) up to failures equivalence [6]. This interleaving equivalence abstracts from causality and respects branching time only to some degree. However, we conjecture that our results are in fact largely independent of this choice and that more discriminating equivalences, such as the history preserving ST-bisimulation of [20],
would yield the same classes of asynchronous nets. Using a linear time equivalence would give rise to larger classes; this possibility is investigated in [18].
Thus we investigate the effect of our three transformations of instantaneous interaction into asynchronous interaction patterns by comparing the behaviours of nets before and after insertion of the silent transitions up to failures equivalence. We show that in the case of full asynchrony, we obtain equivalent behaviour exactly for conflict-free Petri nets. Further we establish
…(Full text truncated)…
This content is AI-processed based on ArXiv data.
