Marisa Llorens

Structural and dynamic changes in concurrent systems: reconfigurable Petri nets

The aim of this work is the modeling and verification of concurrent systems subject to dynamic changes using extensions of Petri nets. We begin by introducing the notion of net rewriting system. In a net rewriting system, a system configuration is described as a Petri net and a change in configuration is described as a graph rewriting rule. We show that net rewriting systems are Turing powerful, that is, the basic decidable properties of Petri nets are lost and, thus, automatic verification in not possible for this class. A subclass of net rewriting systems are reconfigurable Petri nets. In a reconfigurable Petri net, a change in configuration amounts to the modification of the flow relations of the places in the domain of the involved rule according to this rule, independently of the context in which this rewriting applies. We show that reconfigurable Petri nets are formally equivalent to Petri nets. This equivalence ensures that all the fundamental properties of Petri nets are still decidable for reconfigurable Petri nets and this model is thus amenable to automatic verification tools. Therefore, the expressiveness of both models is the same, but, with reconfigurable Petri nets, we can easily and directly model systems that change their structure dynamically.

Dynamic Slicing Techniques for Petri Nets

Petri nets provide a means for modelling and verifying the behavior of concurrent systems. Program slicing is a well-known technique in imperative programming for extracting those statements of a program that may affect a given program point. In the context of Petri nets, computing a net slice can be seen as a graph reachability problem. In this paper, we propose two slicing techniques for Petri nets that can be useful to reduce the size of the considered net, thereby simplifying subsequent analysis and debugging tasks by standard Petri net techniques.

The MEB and CEB Static Analysis for CSP Specifications

This work presents a static analysis technique based on program slicing for CSP specifications. Given a particular event in a CSP specification, our technique allows us to know what parts of the specification must necessarily be executed before this event, and what parts of the specification could be executed before it in some execution. Our technique is based on a new data structure which extends the Synchronized Control Flow Graph (SCFG). We show that this new data structure improves the SCFG by taking into account the context in which processes are called and, thus, makes the slicing process more precise.

Introducing structural dynamic changes in Petri nets: Marked-controlled reconfigurable nets

The aim of this work is the modeling and verification of concurrent systems that are subject to dynamic changes by using extensions of Petri nets. In previous studies, we have introduced net rewriting systems and a subclass of these called reconfigurable nets. In a net rewriting system, a system configuration is described as a Petri net and a change in configuration is described as a graph rewriting rule. A reconfigurable net is a net rewriting system where a change in configuration amounts to a modification in the flow relations of the places in the domain of the involved rule in accordance with this rule, independently of the context in which this rewriting applies. In both models, the enabling of a rule depends only on the net topology. Here we introduce marked-controlled net rewriting systems and marked-controlled reconfigurable nets where the enabling of a rule also depends on the net marking. We show an implementation of marked-controlled reconfigurable nets with Petri nets. Even though the expressiveness of both models is the same, with marked-controlled reconfigurable nets, we can easily and directly model systems that change their structure dynamically. It may be more efficient to directly implement the methods of verification of properties of Petri nets on the marked-controlled reconfigurable nets model.

SOC: a slicer for CSP specifications

This paper describes SOC, a program slicer for CSP specifications. In order to increase the precision of program slicing, SOC uses a new data structure called Context-sensitive Synchronized Control Flow Graph (CSCFG). Given a CSP specification, SOC generates its associated CSCFG and produces from it two different kinds of slices; which correspond to two different static analyses. We present the tools architecture, its main applications and the results obtained from experiments conducted in order to measure the performance of the tool.

Marked-Controlled Reconfigurable Workflow Nets

In previous studies, we have introduced marked-controlled net rewriting systems and a subclass of these called marked-controlled reconfigurable nets. The main goal of these models is to analyze, simulate and verify concurrent and distributed systems that are subject to structural dynamic changes. In a marked-controlled net rewriting system, a system configuration is described as a Petri net, and a change in configuration is described as a graph rewriting rule. A marked-controlled reconfigurable net is a marked-controlled net rewriting system where a change in configuration amounts to a modification in the flow relations of the places in the domain of the involved rule in accordance with this rule, independently of the context in which this rewriting applies. In both models, the enabling of a rule not only depends on the net topology, but also depends on the net marking according to control places. In this work, we introduce marked-controlled reconfigurable workflow nets, based on Van der Aalsts workflow nets and marked-controlled reconfigurable nets, in order to model workflow systems handling structural dynamic changes. A characterization of the soundness property for marked-controlled reconfigurable workflow nets is also provided

Generating a Petri net from a CSP specification: A semantics-based method

The specification and simulation of complex concurrent systems is a difficult task due to the intricate combinations of message passing and synchronizations that can occur between the components of the system. Two of the most extended formalisms used to specify, verify and simulate such kind of systems are CSP and the Petri nets. This work introduces a new technique that allows us to automatically transform a CSP specification into an equivalent Petri net. The transformation is formally defined by instrumenting the operational semantics of CSP. Because the technique uses a semantics-directed transformation, it produces Petri nets that are closer to the CSP specification and thus easier to understand. This result is interesting because it allows CSP developers not only to graphically animate their specifications through the use of the equivalent Petri net, but it also allows them to use all the tools and analysis techniques developed for Petri nets.

Static slicing of explicitly synchronized languages

Static analysis of concurrent languages is a complex task due to the non-deterministic execution of processes. If the concurrent language being studied allows process synchronization, then the analyses are even more complex (and thus expensive), e.g., due to the phenomenon of deadlock. In this work we introduce a static analysis technique based on program slicing for concurrent and explicitly synchronized languages in general, and CSP in particular. Concretely, given a particular point in a specification, our technique allows us to know what parts of the specification must necessarily be executed before this point, and what parts of the specification could be executed before it. Our technique is based on a new data structure that extends the Synchronized Control Flow Graph (SCFG). We show that this new data structure improves the SCFG by taking into account the context in which processes are called and, thus, it makes the slicing process more precise. The technique has been implemented and tested with real specifications, producing good results. After formally defining our technique, we describe our tool, its architecture, its main applications and the results obtained from several experiments conducted in order to measure the performance of the tool.

A tracking semantics for CSP

CSP is a powerful language for specifying complex concurrent systems. Due to the non-deterministic execution order of processes and to synchronizations, many analyses such as deadlock analysis, reliability analysis, and program slicing try to predict properties of the specification which can guarantee the quality of the final system. These analyses often rely on the use of CSPs traces. In this work, we introduce the theoretical basis for tracking concurrent and explicitly synchronized computations in process algebras such as CSP. Tracking computations is a difficult task due to the subtleties of the underlying operational semantics which combines concurrency, non-determinism and non-termination. We define an instrumented operational semantics that generates as a side-effect an appropriate data structure (a track) which can be used to track computations. Formal definition of a tracking semantics improves the understanding of the tracking process, but also, it allows to formally prove the correctness of the computed tracks.

An algorithm to generate the context-sensitive synchronized control flow graph

The verification of industrial systems specified with CSP often implies the analysis of many concurrent and synchronized components. The cost associated to these analyses is usually very high, and sometimes prohibitive, due to the complexity imposed by the non-deterministic execution order of processes and to the restrictions imposed on this order by synchronizations. To overcome this problem, there has been a recent proposal that allows to statically simplify a specification before the analyses. This simplification allows to drastically reduce the time needed by the analyses because it reduces the state explosion. Unfortunately, the approach has been implemented but it has not been formalized neither proved correct. In this paper, we formally define the data structures needed to automatically simplify a CSP specification and we define an algorithm able to automatically generate these data structures.