Results 1  10
of
97
Evolving Algebras 1993: Lipari Guide
, 1995
"... Contents 1 Introduction 3 2 Static Algebras and Updates 4 2.1 Static Algebras: Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 2.2 Vocabularies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 2.3 Definition of Static Algebras . . . . . ..."
Abstract

Cited by 405 (34 self)
 Add to MetaCart
Contents 1 Introduction 3 2 Static Algebras and Updates 4 2.1 Static Algebras: Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 2.2 Vocabularies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 2.3 Definition of Static Algebras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 2.4 Terms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 2.5 Locations and Updates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 2.6 Update Sets and Families of Update Sets . . . . . . . . . . . . . . . . . . . . . . . . 6 2.7 Conservative Determinism vs. Local Nondeterminism . . . . . . . . . . . . . . . . . . 7 3 Sequential Evolving Algebras 7 3.1 Basic Transition Rules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 3.1.1 Update Instructions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 3.1.2 Two Rule Constructors . . . .
Modeling Languages: Syntax, Semantics and All That Stuff Part I: The Basic Stuff
, 2000
"... The motivation for this paper, the first in a planned series of three parts, is the multitude of concepts surrounding the proper definition of complex modeling languages for systems and software, and the confusion that this often causes. ..."
Abstract

Cited by 61 (1 self)
 Add to MetaCart
The motivation for this paper, the first in a planned series of three parts, is the multitude of concepts surrounding the proper definition of complex modeling languages for systems and software, and the confusion that this often causes.
A Partial Order Approach to Branching Time Logic Model Checking
 Information and Computation
, 1994
"... Partial order techniques enable reducing the size of the state graph used for model checking, thus alleviating the `state space explosion' problem. These reductions are based on selecting a subset of the enabled operations from each program state. So far, these methods have been studied, implemented ..."
Abstract

Cited by 54 (12 self)
 Add to MetaCart
Partial order techniques enable reducing the size of the state graph used for model checking, thus alleviating the `state space explosion' problem. These reductions are based on selecting a subset of the enabled operations from each program state. So far, these methods have been studied, implemented and demonstrated for assertional languages that model the executions of a program as computation sequences, in particular the logic LTL (linear temporal logic). The present paper shows, for the first time, how this approach can be applied to languages that model the behavior of a program as a tree. We study here partial order reductions for branching temporal logics, e.g., the logics CTL and CTL (all logics with the nexttime operator removed) and process algebras such as CCS. Conditions on the subset of successors from each node to guarantee reduction that preserves CTL properties are given. Provided experimental results show that the reduction is substantial. 1 Introduction Partial ord...
Interpreting Message Flow Graphs
 Formal Aspects of Computing
, 1995
"... We give a semantics for Message Flow Graphs(MFGs), which play the role for interprocess communication that Program Dependence Graphs play for control ow in parallel processes. MFGs have been used to analyse parallel code, and are closely related to Message Sequence Charts and Time Sequence Diagrams ..."
Abstract

Cited by 48 (9 self)
 Add to MetaCart
We give a semantics for Message Flow Graphs(MFGs), which play the role for interprocess communication that Program Dependence Graphs play for control ow in parallel processes. MFGs have been used to analyse parallel code, and are closely related to Message Sequence Charts and Time Sequence Diagrams in telecommunications systems. Our requirements are rstly, to determine unambiguously exactly what execution traces are speci ed by anMFG, and secondly, to use a nitestate interpretation. Our methods function for both asynchronous and synchronous communications. From a set of MFGs, we de ne a transition system of global states, and from that a Buchi automaton by considering safety and liveness properties of the system. In order easily to describe liveness properties, we interpret the traces of the transition system as a model of MannaPnueli temporal logic. Finally,we describe the expressive power of MFGs by mimicking an arbitrary Buchi automaton by means of a set of MFGs. 1.
Modeling and Analysis of Timed Petri Nets Using Heaps of Pieces
, 1997
"... We show that safe timed Petri nets can be represented by special automata over the (max,+) semiring, which compute the height of heaps of pieces. This extends to the timed case the classical representation a la Mazurkievicz of the behavior of safe Petri nets by trace monoids and trace languages. Fo ..."
Abstract

Cited by 46 (17 self)
 Add to MetaCart
We show that safe timed Petri nets can be represented by special automata over the (max,+) semiring, which compute the height of heaps of pieces. This extends to the timed case the classical representation a la Mazurkievicz of the behavior of safe Petri nets by trace monoids and trace languages. For a subclass including all safe Free Choice Petri nets, we obtain reduced heap realizations using structural properties of the net (covering by safe state machine components). We illustrate the heapbased modeling by the typical case of safe jobshops. For a periodic schedule, we obtain a heapbased throughput formula, which is simpler to compute than its traditional timed event graph version, particularly if one is interested in the successive evaluation of a large number of possible schedules. Keywords Timed Petri nets, automata with multiplicities, heaps of pieces, (max,+) semiring, scheduling. I. Introduction The purpose of this paper 1 is to prove the following result: Timed safe Pe...
Complexity Results for 1safe Nets
, 1993
"... We study the complexity of several standard problems for 1safe Petri nets and some of its subclasses. We prove that reachability, liveness, and deadlock are all PSPACEcomplete for 1safe nets. We also prove that deadlock is NPcomplete for freechoice nets and for 1safe freechoice nets. Finally, ..."
Abstract

Cited by 44 (7 self)
 Add to MetaCart
We study the complexity of several standard problems for 1safe Petri nets and some of its subclasses. We prove that reachability, liveness, and deadlock are all PSPACEcomplete for 1safe nets. We also prove that deadlock is NPcomplete for freechoice nets and for 1safe freechoice nets. Finally, we prove that for arbitrary Petri nets, deadlock is equivalent to reachability and liveness. This paper is to be presented at FST&TCS 13, Foundations of Software Technology & Theoretical Computer Science, to be held 1517 December 1993, in Bombay, India. A version of the paper with most proofs omitted is to appear in the proceedings. 1 Introduction Petri nets are one of the oldest and most studied formalisms for the investigation of concurrency [33]. Shortly after the birth of complexity theory, Jones, Landweber, and Lien studied in their classical paper [24] the complexity of several fundamental problems for Place/Transition nets (called in [24] just Petri nets). Some years later, Howell,...
Concurrent Transition Systems
 Theoretical Computer Science
, 1989
"... : Concurrent transition systems (CTS's), are ordinary nondeterministic transition systems that have been equipped with additional concurrency information, specified in terms of a binary residual operation on transitions. Each CTS C freely generates a complete CTS or computation category C , whose ..."
Abstract

Cited by 40 (5 self)
 Add to MetaCart
: Concurrent transition systems (CTS's), are ordinary nondeterministic transition systems that have been equipped with additional concurrency information, specified in terms of a binary residual operation on transitions. Each CTS C freely generates a complete CTS or computation category C , whose arrows are equivalence classes of finite computation sequences, modulo a congruence induced by the concurrency information. The categorical composition on C induces a "prefix" partial order on its arrows, and the computations of C are conveniently defined to be the ideals of this partial order. The definition of computations as ideals has some pleasant properties, one of which is that the notion of a maximal ideal in certain circumstances can serve as a replacement for the more troublesome notion of a fair computation sequence. To illustrate the utility of CTS's, we use them to define and investigate a dataflowlike model of concurrent computation. The model consists of machines, which ...
ModelChecking of Correctness Conditions for Concurrent Objects
 Information and Computation
, 1996
"... The notions of serializability, linearizability and sequential consistency are used in the specification of concurrent systems. We show that the model checking problem for each of these properties can be cast in terms of the containment of one regular language in another regular language shuffled us ..."
Abstract

Cited by 39 (4 self)
 Add to MetaCart
The notions of serializability, linearizability and sequential consistency are used in the specification of concurrent systems. We show that the model checking problem for each of these properties can be cast in terms of the containment of one regular language in another regular language shuffled using a semicommutative alphabet. The three model checking problems are shown to be, respectively, in Pspace, in Expspace, and undecidable. 1 Introduction A common way of specifying concurrent systems is to describe the desired sequential behavior of the system, and then to allow the implementation to execute certain operations in parallel, provided the appearance of sequential behavior is maintained for a suitable observer. The earliest such notion of correctness was serializability (see, for instance, [EGLT76, Pap86, BHG87]), which requires that a collection of transactions that are scheduled in parallel must produce the same result as the same transactions scheduled in some sequential ord...
Refinement of Actions and Equivalence Notions for Concurrent Systems
 Acta Informatica
, 1998
"... This paper combines and extends the material of [GGa/c/d/e], except for the part in [GGc] on refinement of transitions in Petri nets and the discussion of TCSPlike parallel composition in [GGe]. An informal presentation of some basic ingredients of this paper appeared as [GGb]. Among others, th ..."
Abstract

Cited by 37 (1 self)
 Add to MetaCart
This paper combines and extends the material of [GGa/c/d/e], except for the part in [GGc] on refinement of transitions in Petri nets and the discussion of TCSPlike parallel composition in [GGe]. An informal presentation of some basic ingredients of this paper appeared as [GGb]. Among others, the treatment of action refinement in stable and nonstable event structures is new. The research reported here was supported by Esprit project 432 (METEOR), Esprit Basic Research Action 3148 (DEMON), Sonderforschungsbereich 342 of the TU Munchen, ONR grant N0001492J1974 and the Human Capital and Mobility Cooperation Network EXPRESS (Expressiveness of Languages for Concurrency). Contents
Using Shape Analysis to Reduce FiniteState Models of Concurrent Java Programs
 In Proceedings of the International Symposium on Software Testing and Analysis
, 1998
"... Finitestate verification (e.g., model checking) provides a powerful means to detect concurrency errors, which are often subtle and difficult to reproduce. Nevertheless, widespread use of this technology by developers is unlikely until tools provide automated support for extracting the required fini ..."
Abstract

Cited by 32 (0 self)
 Add to MetaCart
Finitestate verification (e.g., model checking) provides a powerful means to detect concurrency errors, which are often subtle and difficult to reproduce. Nevertheless, widespread use of this technology by developers is unlikely until tools provide automated support for extracting the required finitestate models directly from program source. Unfortunately, the dynamic features of modern languages such as Java complicate the construction of compact finitestate models for verification. In this paper, we show how shape analysis, which has traditionally been used for computing alias information in optimizers, can be used to greatly reduce the size of finitestate models of concurrent Java programs by determining which heapallocated variables are accessible only by a single thread, and which shared variables are protected by locks. We also provide several other statespace reductions based on the semantics of Java monitors. A prototype implementation of the reductions demonstrates their ...