Some equivalence notions for concurrent systems. An overview

Fine-Grained Parallel and Distributed Spatial Stochastic Simulation of Biological Reactions

Contracts as games on event structures

A design calculus for concurrent systems or, more specifically, for reactive systems, will need the following components: •A (logical) language for the property oriented specification of systems. •A system description language to represent abstract and more concrete design specifications. •Models for concurrent systems which are used as semantic domains for both the logical language and the system description language.

Modelling and analysis of kanban-controlled (just-in-time) production systems under realistic assumptions presents a number of challenges, including the ability to conduct both qualitative and quantitative analysis, and the ability to model control policies. These challenges are due, in part, to station interdependence, blocking and starvation due to limited buffer spaces, and the necessity of modelling both material and kanban flows. Petri nets (PNs) have recently emerged as a promising approach for modelling manufacturing systems. PNs are a graphical and mathematical technique useful for modelling concurrent, asynchronous, distributed, parallel, non-deterministic and stochastic systems. PN models can be analysed to determine both their qualitative and quantitative properties. In this paper, we develop stochastic, coloured PN (SCPN) models of a JIT system utilizing two different kanban control policies: a traditional kanban system (TKS) policy and a flexible kanban system (FKS) policy. The resulting models can be used to represent JIT systems of arbitrary size, producing single or multiple types of products, with fixed order points 1. The models are shown to be live and bounded, and can be simulated to produce quantitative results. Sample simulation results are presented to illustrate the models' capabilities.

Proving correctness of concurrent systems is quite difficult because of the high level of nondeterminism, especially in large and complex ones. AMC is a model checking system for verifying asynchronous concurrent systems by using branching time temporal logic. This paper introduces the techniques of the modelling approach, especially how to construct models for large concurrent systems with the concept of hierarchy, which has been proved to be effective and practical in verifying large systems without a large growth of cost.

Connectedness and synchronization

Jeff Magee and Jeff Kramer John Wiley and Sons, New York, NY, 1999, 374 pp. ISBN 0471987107, $64.99 The book is an introductory text to the ideas, concepts, and topics of concurrency. The text focuses on understanding concepts and techniques, and problems of concurrency, not on the implementation or language. The author's overall goal is that by a combination of learning and doing using Java should make the process of acquiring the skills relating to concurrency interesting, enjoyable, and challenging. The Java language is thus used only for illustration and programming experience of the reader. The book is intended for a computer science student or software developer. A background in programming is expected, as well as some familiarity with the essential concepts of object-oriented programming. Knowledge of the Java programming language and operating systems concepts is beneficial but not required. After reading the text, a reader can expect to have a broad understanding of the concepts of concurrency, the problems that arise, methods to emphasis desirable properties in a concurrent system, and ways to avoid the undesirable ones. The text provides a systematic treatment of concepts, as means to rigorously specify and model concurrent systems, with Java examples to animate and illustrate the concepts discussed. The book is organized into twelve chapters, with three appendices. The first eight chapters provide a concise and comprehensive foundation of concurrency, with the remaining four chapters focusing on more advanced concepts. The latter four chapters are somewhat supplemental and can be read at the discretion of the reader. The content of the text is self-contained, with no reliance upon external references. The authors provide a concluding set of notes and further topics which reference external works, but these are not used in the chapter contents. The introduction provides the foundation for the book, and an idea of what will follow in the rest of the text. The basics of modeling and Java are covered. Authors follow with the concepts of processes, threads and with the idea of concurrency. The emphasis is on using Java, and on the notation used to define a concurrent process or thread. The discussion continues covering interleaving and asynchronous concurrency. Various details about composition of parallel processes and finite state processing modeling are presented. The programming of concurrent execution using Java is then examined via the concept of multiple threads. Here, sharing objects among Java threads is also discussed. The concept of conditional synchronization is covered next, and is used to construct a monitor. The methods of the base object in Java is used, and a waiting queue associated with a Java object is discussed and implemented. This discussion is followed by introduction of deadlock. Authors show the conditions necessary for a deadlock to occur and present an analysis of a concurrent system establishing that such a system is deadlock-free. The classic Dining Philosopher's problem is used to illustrate the distinction between finding deadlocks in models and in programs. The presentation continues with the safety property (that asserts that nothing bad happens), and the liveliness property (that asserts that nothing good happens). Here, authors use the material on model-based design to consolidate many of the concepts previously discussed. No one modeling method or design methodology is emphasized. Then creation and elimination of threads in a running program is covered next. The dynamic starting and stopping of Java threads is presented. The discussion moves then to messaging passing. Asynchronous and synchronous messaging is presented with Java programming examples. The concept of a rendezvous, allowing for interaction in a messaging system, is also presented. Based on the concepts developed so far filter-pipeline, supervisor-worker, and announcer-listener concurrent architectures are examined. Java programs demonstrating how the elements of each model interact at runtime are developed. The presentation completes with modeling and implementing of timed systems. Time is signaled by the passage of successive time ticks. The authors then elaborate on a system that is event-based rather than thread-based. Java programs are used to illustrate in implementation the concepts discussed. The three appendices provide a reference, specification, and listing of semantics for the finite-state modeling algebra used by the authors throughout the book. The text is ideal for teaching in a classroom environment, or for a motivated reader to use for self-paced learning. Its organization follows a logical train of discussion and thought, with each chapter building successively on the other, with the more difficult concepts and topics withheld until later. This gradual approach makes the material flow smoothly and cohesively from the beginning to the end. The book is intended as a textbook, so does organize the material and discussion as one, but does not become too dry or bland to stifle the reader's interest in the material. The examples are inter-mixed with the discussion to highlight and emphasize essential points the authors make in each chapter. The text illustrates concepts well under discussion, and does not become a long-winded recital of theory. The topics examined are fundamental to concurrency, and are well illustrated and discussed, but no one topic is examined extensively. The code examples are well written concerning the programming style, indentation and comments. A CD is provided, containing the codes from the book. In addition supplementary material consisting of presentation slides and an errata is provided on the author's WWW site, as well as on the CD. The book is up to date both on the topics of concurrency, and with the Java applets, code, and programs used to illustrate them. Later, as the Java language evolves, the examples may need to be updated, but for the time being the text well represents that state of the Java language. William F. Gilreath, Micron Technology, Inc., Boise Idaho

Representation of scopes of names is important for analysis and verification of concurrent systems. However, it is difficult to represent the scopes of channel names precisely with models based on process algebra.We introduced a model of concurrent systems with higher-order communication based on graph rewriting in our previous work. A bipartite directed acyclic graph represents a concurrent system that consists of a number of processes and messages in that model. The model can represent the scopes of local names precisely. We defined an equivalence relation such that two systems are equivalent not only in their behavior, but also in extrusion of scopes of names. This paper shows that our equivalence relation is a congruence relation w.r.t. τ-prefix, new-name, replication and composition, even when higher-order communication is allowed. We also show our equivalence relation is not congruent w.r.t. input-prefix though it is congruent w.r.t. input-prefix in the first-order case.

This paper presents a proof technique for proving refinements for general state-based models of concurrent systems that reduces proving forward simulations to thread-local, step-local proof obligations. The approach has been implemented in our theorem prover KIV, which translates imperative programs to a set of transition rules and generates proof obligations accordingly. Instances of this proof technique should also be applicable to systems specified with ASM rules, B events, or Z operations. To exemplify the proof methodology, we demonstrate it with two case studies. The first verifies linearizability of a lock-free implementation of concurrent hash sets by showing that it refines an abstract concurrent system with atomic operations. The second applies the proof technique to the verification of opacity of Transactional Mutex Locks (TML), a Software Transactional Memory algorithm. Compared to the standard approach of proving a forward simulation directly, both case studies show a significant reduction in proof effort.

: This final technical report summarizes the research accomplished under the Expert Science and Engineering (ES&E) program by the University of California at Berkeley through Syracuse University. The research effort, entitled 'Parallel Extensions for Object Oriented Programming', examined communication aspects leading to language support for parallel computation. The work undertaken in this effort has extended concurrent programming languages in their communication primitives. Although many abstraction mechanisms have been used in programming languages, including control abstraction mechanisms (such as procedures) and data abstraction mechanisms (such as data types), communication abstraction mechanisms have been found to be the most useful for parallel/ concurrent programming paradigms. Work accomplished in this effort has extended those mechanisms, concentrating on inter-process communication. A formal model for concurrent systems, called the Synchronous Token-based Communicating State (STOCS) model, has been used to model and analyze concurrent systems. Since present concurrent languages do not support any form of analysis of the communication structure of programs, two new constructs based on STOCS formalism have been developed to support high level specification - handshake and unit. A fair and efficient algorithm for execution of multi-process shared events is also presented.

Petri net models are used to detect and isolate faults in case of discrete event systems as manufacturing, robotic, communication and transportation systems. This chapter addresses two problems. The first one is the structure designs and parameters identification of the Petri net models according to the observation and analysis of the sequences of events that are collected. Deterministic and stochastic time Petri nets are concerned. The proposed method is based on a statistical analysis of data and has a practical interest as long as sequences of events are already saved by supervision systems. The second problem concerns the use of the resulting Petri net models to detect, isolate and characterize faults in discrete event systems. This contribution includes the characterization of intermittent faults. This issue is important because faults are often progressive from intermittent to definitive and early faults detection and isolation improve productivity and save money and resources.

Systematic Refinement of Performance Models for Concurrent Component-based Systems

Finite transition systems play a central role as formal models for reactive and concurrent systems. A promising technique for automatically verifying transition systems is model checking. In the model-theoretic approach one mechanically determines whether a system ts meets a specification f (expressed as a formula of some temporal logic) by checking whether ts is a model for f. The authors present a kernel specification formalism BTL. They discuss efficient (linear-time) global and local model checking algorithms for BTL. The global algorithm will compute all states that satisfy a given formula whereas the local algorithm will only check a formula for one state (typically the initial system state). Both algorithms run in time linear in the size of the transition system and the length of the formula. >

Reasoning about equilibria in game-like concurrent systems

We show that observational equivalences for standard, partial and regular algebras are bisimulation equivalences in the setting of open maps, proposed in [JNW93] as an abstract approach to behavioural equivalences of processes. The main advantage of the results is capturing models for sequential and concurrent systems in a uniform framework. In such an abstract setting we formulate the property of determinism, shared by all the algebras considered in this paper, and identify some interesting facts about bisimilarity in the deterministic case. All the results for standard, regular and partial algebras are obtained by the applications of general theorems proved in the paper, which we expect to be applicable also in other contexts.KeywordsFull SubcategoryLeft AdjointForgetful FunctorPartial AlgebraAbstract Data TypeThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.