Concurrency Relations Research Articles

The correctness of concurrencies in (reversible) concurrent calculi

This article designs a general principle to check the correctness of the definition of concurrency (a.k.a. independence) of events for concurrent calculi. Concurrency relations are central in process algebras, but also two-sided: they are often defined independently on composable and on coinitial transitions, and no criteria exist to assess whether they “interact correctly”. This article starts by examining how reversibility can provide such a correctness of concurrencies criterion, and its implications. It then defines, for the first time, a syntactical definition of concurrency for CCSK, a reversible declension of the calculus of communicating systems. To do so, according to our criterion, requires to define concurrency relations for all types of transitions along two axes: direction (forward or backward) and concomitance (coinitial or composable). Our definition is uniform thanks to proved transition systems and satisfies our sanity checks: square properties, sideways diamonds, but also the reversible checks (reverse diamonds and causal consistency). We also prove that our formalism is either equivalent to or a refinement of pre-existing definitions of concurrency for reversible systems. We conclude by discussing additional criteria and possible future works.

Adaptive Selection and Clustering of Partial Reconfiguration Modules for Modern FPGA Design Flow

Dynamic Partially Reconfiguration (DPR) on FPGA has attracted significant research interest in recent years since it provides benefits such as reduced area and flexible functionality. However, due to the lack of supporting synthesis tools in the current DPR design flow, leveraging benefits from DPR requires specific design expertise with laborious manual design effort. Considering the complicated concurrency relations among various functions, it is challenging to select appropriate Partial Reconfiguration Modules (PR Modules) and cluster them into proper groups with a proper reconfiguration schedule so that the hardware modules can be swapped in and out correctly during the run time. Furthermore, the design of PR Modules also impacts reconfiguration latency and resource utilization greatly. In this paper, we propose a Maximum-Weight Independent Set model to formulate the PR Module selection and clustering problem so that the original manual exploration can be solved efficiently and automatically. We also propose a step-wise adjustment configuration prefetching strategy incorporated in our model to generate optimized reconfiguration schedules. Our proposed approach not only supports various design constraints but also can consider multiple objectives such as area and reconfiguration delay. Experimental results show that our approach can optimize resource utilization and reduce reconfiguration delay with good scalability. Especially, the implementation of the real design case shows that our approach can be embedded in Xilinx's DPR design flow successfully.

Checking Missing-Data Errors in Cyber-Physical Systems Based on the Merged Process of Petri Nets

Missing-data errors easily occur in cyber-physical systems (CPSs). Although many business process modeling notation (BPMN)-based methods are proposed to model CPSs and detect errors, it is hard to automatically verify their correctness, especially in the data flows, due to their lack of formal specifications. By comparison, Petri nets, as a formal method, are widely used to detect data-flow errors. However, these methods easily suffer from the state-space explosion problem. This is mainly because their reachability graphs or state transition graphs are based on the interleaving semantics. As an unfolding technique of Petri net, a merged process can characterize concurrency relations and alleviate this problem. Thus, we utilize the merged process of Petri net with data (PD-net) to check the missing-data errors of the CPS. We first transform a BPMN of the CPS into a PD-net and generate its merged process. Meanwhile, we analyze its structural behaviors and data-adjacent events. Furthermore, we propose an algorithm for checking missing-data errors. In addition, a case study and some experiments are done to show the practicality and effectiveness of our method.

Local Concurrency Detection in Business Process Event Logs

Process mining techniques aim at analyzing records generated during the execution of a business process in order to provide insights on the actual performance of the process. Detecting concurrency relations between events is a fundamental primitive underpinning a range of process mining techniques. Existing approaches to this problem identify concurrency relations at the level of event types under a global interpretation. If two event types are declared to be concurrent, every occurrence of one event type is deemed to be concurrent to one occurrence of the other. In practice, this interpretation is too coarse-grained and leads to over-generalization. This article proposes a finer-grained approach, whereby two event types may be deemed to be in a concurrency relation relative to one state of the process, but not relative to other states. In other words, the detected concurrency relation holds locally, relative to a set of states. Experimental results both with artificial and real-life logs show that the proposed local concurrency detection approach improves the accuracy of existing concurrency detection techniques.

Detecting Data Inconsistency Based on the Unfolding Technique of Petri Nets

The errors of data inconsistency occur in a concurrent system when some concurrent operations are conducted improperly. The model-checking technique is widely used to detect them based on the state transition graph. However, the state space explosion problem is the biggest obstacle for this technique, since the state transition graph is based on the interleaving semantics that can result in a rapid increase of the graph scale. In addition, data inconsistency is closely related with concurrent operations, but the state transition graph hardly characterizes concurrency due to its interleaving semantics. The unfolding technique of Petri nets can both alleviate the state explosion and characterize concurrency because it is based on the concurrent semantics. In this paper, we define Petri net with data to model concurrent systems with three kinds of data operations: read , write, and delete , and then formalize data inconsistency . We propose an unfolding method to produce a finite complete prefix (FCP) for each PD-net. Then, a matrix that represents all concurrency relations of transitions is constructed in view of FCP. Furthermore, the error of data inconsistency can be detected via this matrix. The related algorithms and the developed tool are introduced, and experiments illustrate their effectiveness and advantages. An example of industrial information system shows the usefulness of our study.

Composition of concurrency relations and marked simple nets

-

Computing Refined Ordering Relations with Uncertainty for Acyclic Process Models

Since the behavior is the essential characteristic of business process models, and ordering relations between execution of tasks can be used to describe the behavior of process models, we need to compute the ordering relations between tasks in process models. This computation can be used for compliance checking and querying process models based on behavior. There are three basic types of ordering relations between two events in a concurrent system, i.e., causal, conflict, and concurrency. In this paper, we refine the causal and concurrency relations with uncertainty according to whether one task is always executed with the other task in the same instance. To compute the refined ordering relations with uncertainty efficiently, we propose some rules for adjacent tasks and some transitive laws for nonadjacent tasks together with their proofs. Based on these rules and laws, we propose an algorithm to compute the refined ordering relations for acyclic process models based on unfolding technology. The algorithm has a biquadrate time to the size of complete prefix unfolding of the original model.

Recognition of concurrency relations between inaccurate lines

In this paper, we propose a new efficient method for recognizing multiple concurrency relations between inaccurately drawn lines. The proposed technique constructs a solution by combining borderline cases. For each line there is a parameter domain, which specifies how the line can move within the borders imposed by a set of support lines and support points. To encode the way in which the borderline cases can be combined we introduce the concept of a rank vector. This vector measures how many degrees of freedom (dof) are left when a line is pushed within its borders towards a solution. Experimental evaluation has demonstrated that with respect to geometric concurrency problems the proposed method can solve problems that are far beyond the reach of conventional non-linear problem-solvers. This is mainly due to the use of rank vectors that encode all the possible ways in which a solution can be constructed.

Diagnostic temporel dans les systèmes répartis à l'aide de dépliages de réseaux de Petri temporels

Monitoring real-time concurrent systems is a challenging task. In this paper we formulate (model-based) supervision by means of hidden state history reconstruction, from event (e.g. alarm) observations. We follow a so-called true concurrency approach using time Petri nets: the model defines explicitly the causal and concurrency relations between the observable events, produced by the system under supervision on different points of observation, and constrained by time aspects.

From Petri Nets to Automata with Concurrency

Automata with concurrency relations are labelled transition systems with a collection of state-dependent binary independence relations for the actions. We show how to associate with each Petri net (place/transition net) such an automaton having the same dynamic behaviour. We characterize the automata arising in this way, and with suitable notions of morphisms for Petri nets and for automata with concurrency relations we extend this correspondence to a coreflection between the associated categories. As a consequence, we derive that these categories have products and conditional coproducts.

Active objects as atomic control structures in BaLinda K

BaLinda K implements objects in a functional framework. Active objects, which permit concurrent execution and tuple exchanges between externally invoked methods and the object body within the confines of an object boundary, are shown to be a useful tool for establishing concurrency relations between parallel tasks.

RECOGNIZABLE AND LOGICALLY DEFINABLE LANGUAGES OF INFINITE COMPUTATIONS IN CONCURRENT AUTOMATA

Automata with concurrency relations [Formula: see text], which occurred in formal verification methods of concurrent programs, are labeled transition systems with a collection of binary relations describing when two actions in a given state of the automaton can happen independently of each other. The concurrency monoid M($\mathcal{A}$) comprises all finite computation sequences of [Formula: see text], modulo a canonical congruence induced by the concurrency relations, with composition as monoid operation. Then M∞($\mathcal{A}$) denotes the set of all infinite products in M($\mathcal{A}$); its elements can be represented by labeled partially ordered sets. Under suitable assumptions on [Formula: see text], we show that a language L in M∞($\mathcal{A}$) is recognizable iff it is definable by a formula of monadic second order logic, and that it is recognizable iff it can be constructed from recognizable languages in M($\mathcal{A}$) using co-rational expressions. This generalizes various recent results in trace theory.

Representation of computations in concurrent automata by dependence orders

An automaton with concurrency relations A is a labelled transition system with a collection of binary relations indicating when two actions in a given state of the automaton can occur independently of each other. The concurrency relations induce a natural equivalence relation for finite computation sequences. We investigate two graph-theoretic representations of the equivalence classes of computation sequences and obtain that under suitable assumptions on A they are isomorphic. Furthermore, the graphs are shown to carry a monoid operation reflecting precisely the composition of computations. This generalizes fundamental graph-theoretical representation results due to Mazurkiewicz in trace theory.

Aperiodic Languages in Concurrency Monoids

Automata with concurrency relations A are labelled transition systems with a collection of binary relations indicating when two events, in a given state of the automaton, are concurrent. We investigate concurrency monoids M ( A ) comprising all finite computation sequences of A , modulo a canonical congruence induced by the concurrency relations, with composition as monoid operation. Under suitable assumptions on A we obtain a characterization of the star- free languages of M ( A ). This generalizes a classical result of M. P. Schützenberger and a result of G. Guaiana, A. Restivo and S. Salemi in trace theory.

Recognizable languages in concurrency monoids

Automata with concurrency relations A are labelled transition systems with a collection of binary relations indicating when two actions, in a given state of the automaton, are concurrent. We investigate concurrency monoids M( A ) comprising all finite computation sequences of A , modulo a canonical congruence induced by the concurrency relations, with composition as monoid operation. Under suitable assumptions on A we obtain a Kleene-type characterization of the recognizable languages of M( A ). This generalizes results of Cori, Métivier, Perrin and Ochmanski in trace theory.

Labelled domains and automata with concurrency

We investigate an operational model of concurrent systems, called automata with concurrency relations. These are labelled transition systems A in which the event set is endowed with a collection of binary concurrency relations which indicate when two events, in a particular state of the automaton, commute. This model generalizes asynchronous transition systems, and as in trace theory we obtain, through a permutation equivalence for computation sequences of A , an induced domain ( D( A ), ⩽). Here, we construct a categorical equivalence between a large category of (“cancellative”) automata with concurrency relations and the associated domains. We show that each cancellative automaton can be reduced to a minimal cancellative automaton generating, up to isomorphism, the same domain. Furthermore, when fixing the event set, this minimal automaton is unique.

CONCURRENT AUTOMATA AND DOMAINS

We introduce an operational model of concurrent systems, called automata with concurrency relations. These are labeled transition systems [Formula: see text] in which the event set is endowed with a collection of symmetric binary relations which describe when two events at a particular state of [Formula: see text] commute. This model generalizes the recent concept of Stark’s trace automata. A permutation equivalence for computation sequences of [Formula: see text] arises canonically, and we obtain a natural domain [Formula: see text] comprising the induced equivalence classes. We give a complete order-theoretic characterization of all such partial orders [Formula: see text] which turn out to be particular finitary domains. The arising domains [Formula: see text] are particularly pleasant Scott-domains, if [Formula: see text] is assumed to be concurrent, i.e. if the concurrency relations of [Formula: see text] depend (in a natural way) locally on each other, but not necessarily globally. We show that both event domains and dI-domains arise, up to isomorphism, as domains [Formula: see text] with well-behaved such concurrent automata [Formula: see text]. We introduce a subautomaton relationship for concurrent automata and show that, given two concurrency domains (D, ≤), (D′, ≤), there exists a nice stable embedding-projection pair from D to D′ iff D, D′ can be generated by concurrent automata [Formula: see text] such that [Formula: see text] is a subautomaton of [Formula: see text]. Finally, we introduce the concept of locally finite concurrent automata as a limit of finite concurrent automata and show that there exists a universal homogeneous locally finite concurrent automaton, which is unique up to isomorphism.

Finite canonical rewriting systems for congruences generated by concurrency relations

WhenC is a concurrency relation on alphabet Σ, then Σ*/=C is a free partially commutative monoid. Here we show that it is decidable in polynomial time whether or not there exists a finite canonical rewriting systemR on Σ such that the congruences ↔R* generated byR and =C induced byC coincide. Further, in case such a systemR exists, one such system can be determined in polynomial time.

Nets, sequential components and concurrency relations

A lattice of unmarked nets is introduced and studied. It is proved that unmarked nets representing the static structure of sequential systems are atoms of that lattice. Marking classes defined by the decomposition of nets into sequential components are introduced and properties (safeness, fireability, etc.) of nets with those marking classes are investigated. The notion of concurrency relation on the system level is defined and discussed. Two different definitions of that relation are given. The first one starts with a given in advance decomposition of a net into sequential components; the second one is constructed on the basis of a given in advance marking class. Both definitions follow from a general concept of the symmetric and irreflexive relation define by a set covering. Petri's postulate about a common element for every global system state and every sequential component is carried up the system level and its strength is discussed. It turns out that if a net is safe and each transition has a possibility to be fired then that postulate implies that the net is decomposable into finite state machines.