ω-Petri Nets

It is difficult to map the execution model of multithreading languages (languages which support fine-grain dynamic thread creation) onto the single stack execution model of C. Consequently, previous work on efficient multithreading uses elaborate frame formats and allocation strategy, with compilers customized for them. This paper presents an alternative cost-effective implementation strategy for multithreading languages which can maximally exploit current sequential C compilers. We identify a set of primitives whereby efficient dynamic thread creation and switch can be achieved and clarify implementation issues and solutions which work under the stack frame layout and calling conventions of current C compilers. The primitives are implemented as a C library and named StackThreads. In StackThreads, a thread creation is done just by a C procedure call, maximizing thread creation performance. When a procedure suspends an execution, the context of the procedure, which is roughly a stack frame of the procedure, is saved into heap and resumed later. With StackThreads, the compiler writer can straightforwardly translate sequential constructs of the source language into corresponding C statements or expressions, while using StackThreads primitives as a blackbox mechanism which switches execution between C procedures.

We implement a new sequentialization algorithm for multi-threaded C programs with dynamic thread creation as a new CSeq module. The novel basic idea of this algorithm is to fix (by a nondeterministic guess) the sequence of write operations in the shared memory and then simulate the behavior of the program according to any scheduling that respects this choice. Simulation is done thread-by-thread and the thread creation mechanism is replaced by function calls.

Proof-carrying code (PCC) is a general framework that can, in principle, verify safety properties of arbitrary machine-language programs. Existing PCC systems and typed assembly languages, however, can only handle sequential programs. This severely limits their applicability since many real-world systems use some form of concurrency in their core software. Recently Yu and Shao proposed a logic-based "type" system for verifying concurrent assembly programs. Their thread model, however, is rather restrictive in that no threads can be created or terminated dynamically and no sharing of code is allowed between threads. In this paper, we present a new formal framework for verifying general multi-threaded assembly code with unbounded dynamic thread creation and termination as well as sharing of code between threads. We adapt and generalize the rely-guarantee methodology to the assembly level and show how to specify the semantics of thread "fork" with argument passing. In particular, we allow threads to have different assumptions and guarantees at different stages of their lifetime so they can coexist with the dynamically changing thread environment. Our work provides a foundation for certifying realistic multi-threaded programs and makes an important advance toward generating proof-carrying concurrent code.

Runtime Mechanisms for Efficient Dynamic Multithreading

Step-Indexed Kripke Model of Separation Logic for Storable Locks

The Nexus Approach to Integrating Multithreading and Communication

We propose a sound, complete, and automatic method for pairwise reachability analysis of higher-order concurrent programs with recursion, nested locks, joins, and dynamic thread creation. The method is based on a reduction to higher-order model checking (i.e., model checking of trees generated by higher-order recursion schemes). It can be considered an extension of Gawlitz et al.’s work on the join-lock-sensitive reachability analysis for dynamic pushdown networks (DPN) to higher-order programs. To our knowledge, this is the first application of higher-order model checking to sound and complete verification of (reasonably expressive models of) concurrent programs.

On the ω-language Expressive Power of Extended Petri Nets

The article focuses on a type of client/server multiagent system. Such system consists of several server environments, each populated by a single server agent and multiple client agents. We propose that a server agent should monitor clients activity in order to perform better. We employ the term agent tracking, introduced by Tambe and Rosenbloom. We introduce the idea of distributed tracking. Our multiagent system includes client tracking agents, which are responsible for agent tracking of clients and are devoted to a server. Each tracking agent executes a single model, which can apply to a single client agent or a group of client agents. All tracking agents work cooperatively and make collective decisions about formation of client groups. Tracking agents derive facts about client behavior and supply the server with conclusions. Generalized nets (GNs - an extension of Petri nets) are used as a tool for modeling multiagent system. A GN model of a single server environment with tracking agents is described.

Reachability Analysis of Synchronized PA Systems

SPN as a tool for risk modeling of fires in process industries

The unfolding technique is an efficient tool to explore the runs of a Petri net in a true concurrency semantics, i.e. without constructing all the interleavings of concurrent actions. But even small real systems are never modeled directly as ordinary Petri nets: they use many high-level features that were designed as extensions of Petri nets. We focus here on two such features: colors and compositionality. We show that the symbolic unfolding of a product of colored Petri nets can be expressed as the product of the symbolic unfoldings of these nets. This is a necessary result in view of distributed computations based on symbolic unfoldings, as they have been developed already for standard unfoldings, to design modular verification techniques, or modular diagnosis procedures, for example. The factorization property of symbolic unfoldings is valid for several classes of colored or high-level nets. We derive it here for a class of (high-level) open nets, for which the composition is performed by connecting places rather than transitions.

Modeling computer software, hardware, and other systems using Petri nets is discussed. The various analysis techniques and extension of Petri nets are considered. Problems in Petri net analysis techniques are examined, and analysis techniques that solve them are given.

The paper deals with reconfigurable embedded control systems following different component-based technologies and/or Architecture Description Languages used today in industry. We define a Control Component as a software unit to support control tasks of the system, which is assumed to be a network of components with precedence constraints. We define an agent-based architecture to handle automatic reconfigurations under well-defined conditions by creating, deleting, or updating components to bring the whole system into safe and optimal behaviors. To cover all possible reconfiguration forms, we model the agent by nested state machines according to the formalism Net Condition/Event Systems (NCESs), which is an extension of Petri nets. In addition, we apply a model checking to verify functional and extra-functional properties according to the temporal logic "Computation Tree Logic” (CTL). The goal is to check the agent reactivity after any evolution of the environment. Several complex networks can implement the system, where each one is executed at a given time when a corresponding reconfiguration scenario is automatically applied by the agent. To check the correctness of each one of them, we apply in several steps a refinement-based approach that automatically specifies feasible Control Components according to NCES. The model checker SESA is automatically applied in each step to verify deadlock properties of new generated components, and it is manually used to verify CTL-based properties according to user requirements. We implement the reconfiguration agent by three modules that allow interpretations of environment evolutions, decisions of useful reconfiguration scenarios, and finally, their applications. Two Industrial Benchmark Production Systems FESTO and EnAS available in our research laboratory are applied to explain the contributions of the paper.

In this paper, we propose the new method for the parallel system design based on expanded the logical coloured Petri net (LCPN). An LCPN is an extended Petri net that solves the problem of system description in previously proposed place/transition nets and coloured Petri nets. This extension of Petri nets is suitable for designing complex control systems and for discussing methods of evaluating such systems realistically. In order to study the behaviour of the server system modelled with this net we simulated a Java program. This program confirmed that this extended Petri net is an effective tool for modelling the parallel system.