Causal Partial Order Research Articles

Classifying invariant structures of step traces

In the study of behaviours of concurrent systems, traces are sets of behaviourally equivalent action sequences. Traces can be represented by causal partial orders. Step traces, on the other hand, are sets of behaviourally equivalent step sequences, each step being a set of simultaneous actions. Step traces can be represented by relational structures comprising non-simultaneity and weak causality. In this paper, we propose a classification of step alphabets as well as the corresponding step traces and relational structures representing them. We also explain how the original trace model fits into the overall framework.

Verification of bounded Petri nets using integer programming

Model checking based on the causal partial order semantics of Petri nets is an approach widely applied to cope with the state space explosion problem. One of the ways to exploit such a semantics is to consider (finite prefixes of) net unfoldings--themselves a class of acyclic Petri nets--which contain enough information, albeit implicit, to reason about the reachable markings of the original Petri nets. In [19], a verification technique for net unfoldings was proposed, in which deadlock detection was reduced to a mixed integer linear programming problem. In this paper, we present a further development of this approach. The essence of the proposed modifications is to transfer the information about causality and conflicts between the events involved in an unfolding, into a relationship between the corresponding integer variables in the system of linear constraints. Moreover, we present some problem-specific optimisation rules, reducing the search space. To solve other verification problems, such as mutual exclusion or marking reachability and coverability, we adopt Contejean and Devie's algorithm for solving systems of linear constraints over the natural numbers domain and refine it, by taking advantage of the specific properties of systems of linear constraints to be solved. Another contribution of this paper is a method of re-formulating some problems specified in terms of Petri nets as problems defined for their unfoldings. Using this method, we obtain a memory efficient translation of a deadlock detection problem for a safe Petri net into an LP problem. We also propose an on-the-fly deadlock detection method. Experimental results demonstrate that the resulting algorithms can achieve significant speedups.

An instrumentation technique for online analysis of multithreaded programs

AbstractThis paper presents an automatic code instrumentation technique, based on multithreaded vector clocks, for extracting the causal partial order on relevant state update events from a running multithreaded program. This technique is used in a formal testing environment, not only to detect, but especially to predict safety errors in multithreaded programs. The prediction process consists of rigorously analyzing other potential executions that are consistent with the causal partial order: some of these can be erroneous despite the fact that the particular observed execution was successful. The technique has been implemented as part of a Java program analysis tool. Copyright © 2006 John Wiley & Sons, Ltd.

Online efficient predictive safety analysis of multithreaded programs

We present an automated and configurable technique for runtime safety analysis of multithreaded programs that is able to predict safety violations from successful executions. Based on a formal specification of safety properties provided by a user, our technique enables us to automatically instrument a given program and create an observer so that the program emits relevant state update events to the observer and the observer checks these updates against the safety specification. The events are stamped with dynamic vector clocks, enabling the observer to infer a causal partial order on the state updates. All event traces that are consistent with this partial order, including the actual execution trace, are then analyzed online and in parallel. A warning is issued whenever one of these potential traces violates the specification. Our technique is scalable and can provide better coverage than conventional testing, but its coverage need not be exhaustive. In fact, one can trade off scalability and comprehensiveness: a window in the state space may be specified allowing the observer to infer some of the more likely runs; if the size of the window is 1, then only the actual execution trace is analyzed, as is the case in conventional testing; if the size of the window is ∞, then all the execution traces consistent with the actual execution trace are analyzed.

On Causality Semantics of Nets with Priorities

In the formal treatment of concurrent computing systems, causality and weak causality can be used to provide abstract specifications of the temporal ‘earlier than’ and ‘not later than’ orderings. In this paper we consider relational structures comprising causality and weak causality — called stratified order structures — which can be used to provide a non-sequential semantics of Petri nets with inhibitor arcs. We show that this approach can be extended to nets augmented with priority specifications. In particular, we demonstrate how to derive stratified order structures for such nets by generalising the standard construction of causal partial orders based on occurrence nets.

Fundamentals of modelling concurrency using discrete relational structures

We consider relational structures \((X,R_1,R_2)\) such that \(X\) is a set and \(R_1,R_2\) are two binary relations on \(X\). For a number of different classes of structures we show that any structure can be represented as the intersection of its maximal extensions. Such a property – called extension completeness – can be seen as a generalisation of Szpilrajn's theorem which states that each partial order is the intersection of its total order extensions. When \(R_1\) can be interpreted as causality and \(R_2\) as ‘weak’ causality we obtain a model of concurrent histories generalising that based on causal partial orders.

Semantics of Inhibitor Nets

We discuss an abstract semantics of concurrent systems generalising causal partial orders. The new semantics employs relational structures-called stratified order structures-which comprise causal partial orders and weak causal partial orders. Stratified order structures can be represented by certain equivalence classes of step sequences-comtraces-directly generalising Mazurkiewicz traces. We use Elementary Net Systems with inhibitor arcs as a system model and show that stratified order structures can provide an abstract semantics which is consistent with their operational semantics expressed in terms of step sequences. Two different types of operational rules are considered. We also construct occurrence nets to enable the generation of stratified order structures for a given run of the net.

Structure of concurrency

Noninterleaving models of concurrency assume that behavioural properties of systems can be adequately modelled in terms of causal partial orders. We claim that the structure of concurrency is richer, with causality being only one of the invariants generated by a set of closely related executions or observations. The model we propose supports three levels of abstraction: the observation level, invariant level and system level; and we will proceed from the bottom (observation) level to the top (system) level. This is in contrast to the way other models for concurrency are introduced, as they essentially support two levels of abstraction, the system level and behavioural level (which includes both observations and invariants), with the direction of development going from the system to behavioural level. In this paper we first discuss the notion of an observation of a concurrent behaviour; in particular, we investigate the role played by interval partial orders. We then introduce a general framework for dealing with invariants generated by sets of closely related observations. This leads to the formulation of the notion of a (concurrent) history whose structural properties are subsequently studied.

Invariants and paradigms of concurrency theory

We introduce a new invariant semantics of concurrent systems which is a direct generalisation of the causal partial order semantics. Our new semantics overcomes some of the problems encountered when one uses causal partial orders alone. We discuss various aspects of the new invariant model. In particular, we outline how the new invariants can be generated by I-safe inhibitor Petri nets.