Behavior Of Concurrent Systems Research Articles

Compositional relaxed concurrency.

There is a broad design space for concurrent computer processors: they can be optimized for low power, low latency or high throughput. This freedom to tune each processor design to its niche has led to an increasing diversity of machines, from powerful pocketable devices to those responsible for complex and critical tasks, such as car guidance systems. Given this context, academic concurrency research sounds notes of both caution and optimism. Caution because recent work has uncovered flaws in the way we explain the subtle memory behaviour of concurrent systems: specifications have been shown to be incorrect, leading to bugs throughout the many layers of the system. And optimism because our tools and methods for verifying the correctness of concurrent code-although built above an idealized model of concurrency-are becoming more mature. This paper looks at the way we specify the memory behaviour of concurrent systems and suggests a new direction. Currently, there is a siloed approach, with each processor and programming language specified separately in an incomparable way. But this does not match the structure of our programs, which may use multiple processors and languages together. Instead we propose a compositional approach, where program components carry with them a description of the sort of concurrency they rely on, and there is a mechanism for composing these. This will support not only components written for the multiple varied processors found in a modern system but also those that use idealized models of concurrency, providing a sound footing for mature verification techniques.This article is part of the themed issue 'Verified trustworthy software systems'.

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.

Probabilistic Programming, Estimation, and Euclidean Model Checking for Aggregate Behavior of Concurrent Systems

Probabilistic Programming, Estimation, and Euclidean Model Checking for Aggregate Behavior of Concurrent Systems

Sheaves and Geometric Logic and Applications to Modular Verification of Complex Systems

In this paper we show that states, transitions and behavior of concurrent systems can often be modeled as sheaves over a suitable topological space. In this context, geometric logic can be used to describe which local properties, of individual systems, are preserved, at a global level, when interconnecting the systems. The main area of application is to modular verification of complex systems. We illustrate the ideas by means of an example involving a family of interacting controllers for trains on a rail track.

An Algebraic Framework for Defining Behaviours of Concurrent Systems. Part 2: The Axiomatic Presentation

The paper is the second part of two-part paper that contributeswith a concept of a process, with operations allowing to define complex processes in terms of their components, with the respective algebras, and with the idea of using the formal tools thus obtained to describe the behaviours of concurrent systems. In the first part a universal model of a process have been introduced and operations on processes have been defined. A process is viewed as a model of a run of a system (discrete, continuous, or of a mixed type). A process may have an initial state (a source), a final state (a target), or both. A process can be represented by a partially ordered multiset. Processes of which one is a continuation of the other can be composed sequentially. Independent processes, can be composed in parallel. Processes may be prefixes, i.e. independent components of initial segments of other processes. It has been shown that processes in a universe of objects and operations on such processes form a partial algebra, called algebra of processes, that is a specific partial category with respect to the sequential composition, and a specific partial monoid with respect to the parallel composition. In the second part the properties of algebras of processes described in the first part are regarded as axioms defining a class of abstract partial algebras, called behaviour-oriented algebras, and properties of such algebras are investigated. In particular, it is shown how some of the behaviour-oriented algebras can be represented as algebras of processes, and how to use them to describe phenomena with states and processes provided with specific structures.

An Algebraic Framework for Defining Behaviours of Concurrent Systems. Part 1: The Constructive Presentation

The paper is the first part of a two-part paper that contributes with a concept of a process viewed as a model of a run of a phenomenon (discrete, continuous, or of a mixed type), with operations allowing to define complex processes in terms of their components, with the respective algebras, and with the idea of using the formal tools thus obtained to describe the behaviours of concurrent systems. A process may have an initial state (a source), a final state (a target), or both. A process can be represented by a partially ordered multiset. Processes of which one can be a continuation of the other can be composed sequentially. Independent processes, i.e. processes which do not disturb each other, can be composed in parallel. Processes may be prefixes, i.e. independent components of initial segments of other processes. Processes in a universe of objects and operations on such processes form a partial algebra, called algebra of processes. Algebras of processes are partial categories with respect to the sequential composition, and partial monoids with respect to the parallel composition. Algebras of processes can be used to define behaviours of concurrent systems. The behaviour of a system can be defined as the set of possible processes of this system with a structure on this set. Such a set is prefix-closed. The structure on this set reflects the prefix order and, possibly, specific features of the behaviour like observability, the relation to flow of real time, etc. Algebras of processes can also be used to define behaviours, to define operations on behaviours similar to those in the existing calculi of behaviours, and to define random behaviours. The first part of the whole paper investigates algebras of processes and their applications to describing behaviours of systems. In the second part the properties of algebras of processes described in the first part are regarded as axioms defining a class of abstract partial algebras, called behaviouroriented algebras, and they initiate a theory of such algebras.

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.

Role-based access control for a distributed calculus

Role-based access control (RBAC) is increasingly attracting attention because it reduces the complexity and cost of security administration by interposing the notion of role in the assignment of permissions to users. In this paper, we present a formal framework relying on an extension of the π-calculus to study the behaviour of concurrent systems in a RBAC scenario. We define a type system ensuring that the specified policy is respected during computations, and a behavioural equivalence to equate systems. We then consider a more sophisticated feature that can be easily integrated in our framework, i.e., the possibility of automatically adding role activations and deactivations to processes to be run under a given policy (whenever possible). Finally, we show how the framework can be easily extended to express significant extensions of the core RBAC model, such as roles hierarchies or constraints determining the acceptability of the system components.

A spatial logic for concurrency (part I)

We present a logic that can express properties of freshness, secrecy, structure, and behavior of concurrent systems. In addition to standard logical and temporal operators, our logic includes spatial operations corresponding to composition, local name restriction, and a primitive fresh name quantifier. Properties can also be defined by recursion; a central aim of this paper is then the combination of a logical notion of freshness with inductive and coinductive definitions of properties.

Behavior relativity of Petri nets

This paper presents a novel methodology for modelling and analyzing of behavior relations of concurrent systems. The set of all firing sequences of a Petri net is an important tool for describing the dynamic behavior of concurrent systems. In this paper, the behavior relativity of two concurrent subsystems in their synchronous composition is presented. Such behavior relativities, including Controlled Relativity, United Relativity, Interactive Relativity and Exclusive Relativity, are defined respectively. The properties of the relativities are discussed in detail. The analysis method for these properties is based on minimum T-invariants, when two subsystems are live bounded Petri nets. A well-known example has also been analyaed using the new methodology to demonstrate the advantages of the proposed methodology.

On translations of temporal logic of actions into monadic second-order logic

The Temporal Logic of Action introduced by Lamport [4] for specifying the behavior of concurrent systems is compared with monadic second order logic which is accepted as an universal formalism for specifying temporal behaviors. The consequences of Lamport's decision to combine in the existential quantifier of TLA, both the standard existential quantifier and the non-logical closure under stuttering are investigated. A continuous time interpretation is provided for TLA and it is argued that this interpretation is more appropriate than the standard discrete time interpretation. Also, some decidability problems are investigated.

AN APPROACH TO OBJECT SYSTEM MODELING BY STATE-BASED OBJECT PETRI NETS

For many years, Petri nets have been used for modeling the behavior of various types of concurrent systems. While these net models are especially well suited to capture the behavior of concurrent systems, it is still the case that net models do not easily capture some important structural aspects of a system, such as modularity. In terms of software systems for distributed applications, the object-oriented paradigm has become a standard for defining modularity and reuse of software. Thus, an evolving direction in Petri net technology is the blending of net features with object-oriented capability. This paper discusses one such approach for state-based object systems.

On some path problems on oriented hypergraphs

The BF-graphs form a particular class of Directed Hypergraphs. For this important family, different applications are known in data bases and artificial intelligence domain. They may also be used to describe the behavior of concurrent systems. We present here a theoretical analysis of several hyperpath problems in BF-graphs, with emphasis on the acyclic BF-graphs. After briefly exposing the basic concepts of directed hypergraphs, we presesnt an algorithm for finding a BF-path. We next discuss the problem of finding a hyperpath cover, and present a polynomial solution for two constrained hyperpath problems.

An extension of Kleene's and Ochmański's theorems to infinite traces

As was noted by Mazurkiewicz, traces constitute a convenient tool for describing finite behaviour of concurrent systems. Extending in a natural way Mazurkiewicz's original definition, infinite traces have recently been introduced enabling one to deal with infinite behaviour of nonterminating concurrent systems. In this paper we examine the basic families of recognizable sets and of rational sets of infinite traces. The seminal Kleene characterization of recognizable subsets of the free monoid and its subsequent extensions to infinite words due to Büchi and to finite traces due to Ochmański are the cornerstones of the corresponding theories. The main result of our paper is an extension of these characterizations to the domain of infinite traces. Using recognizing and weakly recognizing morphisms, as well as a generalization of the Schützenberger product of monoids, we prove various closure properties of recognizable trace languages. Moreover, we establish normal-form representations for recognizable and rational sets of infinite traces.

The PSF toolkit

The use of formal description techniques to describe the behaviour of concurrent systems is still increasing. With the growing complexity of the problems tackled using formal methods, the need for support by computer tools is becoming more and more apparent. This paper describes a tool environment for the formal specification language PSF. An introduction to PSF, as well as to the internal languages used by the toolkit is given. The three main tools from the toolkit described in this paper are a term rewriter, a simulator and a proof assistant. We discuss experiences in usage and links with other tool environments. A comparison between PSF and LOTOS has been included in an appendix.

An exercise in formalizing the description of a concurrent system

SUMMARY LOTOS is one of the most recent formal description languages to appear and one of very few with a standard definition. It has both a process algebra and an abstract data-type component, and these facilities are used in combination to describe the behaviour of concurrent systems. The purpose of this paper is to examine, in a tutorial style, what is involved in constructing and taking benefit from such descriptions. The presentation is illustrated through the development of two formal descriptions for the children’s game of pass-the-parc el. These descriptions and a concise summary of the main features of LOTOS are given as appendices. Many of the points made in the paper apply equally well to other process-oriented languages such as CCS and CSP.

Algorithm to construct the behavior of concurrent systems represented by modified path expressions

The operation of a concurrent system is represented by a set of labeled partially ordered sets (traces). An efficient procedure is suggested for generating the set of all traces in systems where the cooperation between concurrent subsystems is described by path expressions of a special kind.

On the synchronization of traces

Trace theory has been developed to describe the behavior of concurrent systems. Synchronization of traces is of special interest for a modular approach. We characterize those trace monoids for which synchronization can be described locally.

Membership problems for regular and context-free trace languages

Trace languages have been introduced in order to describe the behaviour of concurrent systems in the same way as usual formal languages do for sequential system. They can be defined as subsets of a free partially commutative monoid and a theory of trace languages can be developed, generalizing the usual formal languages theory. In this paper, the time complexity of membership problems for regular and context-free trace languages is investigated. It is proved that the membership problem for context free trace languages can be solved in time O ( BM ( n α )), where α is the dimension of the greatest clique of the concurrency relation C and BM ( n ) is the time required for multiplying two arbitrary n × n boolean matrices. For regular trace languages, our method gives an algorithm which requires O ( n α ) time. Finally, the uniform membership problem is shown to be NP-complete.

Specifying concurrent objects

The object-oriented style of programming (OOP) is gaining increasing importance as a practical technique for organizing large designs and programs. Another striking aspect of OOP is its potential f...