Results 1  10
of
28
Refining Multiset Transformers
 Communications of the ACM
"... Gamma is a minimal language based on local multiset rewriting with an elegant chemical reaction metaphor. The virtues of this paradigm in terms of systematic program construction and design of parallel programs have been argued in previous papers. Gamma can also be seen as a notation for coordinatin ..."
Abstract

Cited by 160 (22 self)
 Add to MetaCart
Gamma is a minimal language based on local multiset rewriting with an elegant chemical reaction metaphor. The virtues of this paradigm in terms of systematic program construction and design of parallel programs have been argued in previous papers. Gamma can also be seen as a notation for coordinating independent programs in a larger application. In this paper, we study a notion of refinement for programs involving parallel and sequential composition operators, and derive a number of programming laws. The calculus thus obtained is applied in the development of a generic "pipelining" transformation, which enables certain sequential compositions to be refined into parallel compositions. Keywords: Gamma, Multiset Rewriting, Program Transformation. 1 Introduction We first describe the general motivation of the work presented here before summarising the main results developed in the body of the paper. 1.1 Motivation The notion of sequential computation has played a central role in the des...
Soft Concurrent Constraint Programming
, 2001
"... . Soft constraints extend classical constraints to represent multiple consistency levels, and thus provide a way to express preferences, fuzziness, and uncertainty. While there are many soft constraint solving algorithms, even distributed ones, by now there seems to be no concurrent programming fram ..."
Abstract

Cited by 50 (32 self)
 Add to MetaCart
. Soft constraints extend classical constraints to represent multiple consistency levels, and thus provide a way to express preferences, fuzziness, and uncertainty. While there are many soft constraint solving algorithms, even distributed ones, by now there seems to be no concurrent programming framework where soft constraints can be handled. In this paper we show how the classical concurrent constraint (cc) programming framework can work with soft constraints, and we also propose an extension of cc languages which can use soft constraints to prune and direct the search for a solution. We believe that this new programming paradigm, called soft cc (scc), can be very useful in many webrelated scenarios. In fact, the language level allows web agents to express their interaction and negotiation protocols, and also to post their requests in terms of preferences, and the underlying soft constraint solver can nd an agreement among the agents even if their requests are incompatible. 1
A Congruence for Gamma Programs
 in Proc. of the 5th workshop on Languages and Compilers for Parallel Computing
, 1993
"... . This paper defines a congruence relation on Gamma programs. Based on this congruence relation, laws for transforming programs are derived. We define an axiomatic semantics for Gamma based on Brookes' transition assertions. The definition of the congruence is in terms of provable satisfiability of ..."
Abstract

Cited by 43 (10 self)
 Add to MetaCart
. This paper defines a congruence relation on Gamma programs. Based on this congruence relation, laws for transforming programs are derived. We define an axiomatic semantics for Gamma based on Brookes' transition assertions. The definition of the congruence is in terms of provable satisfiability of such assertions. We consider the relationship between our congruence and other orderings that have been proposed in the literature. 1 Introduction In this paper we study the problem of transforming programs expressed in the Gamma programming formalism. We aim at defining a relation between Gamma programs that captures when one program mimics another program. This relation allows us to decide when we can safely replace one program by another i.e., it gives us a means of expressing the correctness of program transformations. Gamma operates with a single data structure, the multiset, and computation proceeds by rewriting multisets of data. Gamma has proved successful in expressing a variety of...
On Validity of Program Transformations in the Java Memory Model
"... Abstract. We analyse the validity of several common program transformations in multithreaded Java, as defined by the Java Memory Model (JMM) section of Chapter 17 of the Java Language Specification. The main design goal of the JMM was to allow as many optimisations as possible. However, we find tha ..."
Abstract

Cited by 41 (0 self)
 Add to MetaCart
Abstract. We analyse the validity of several common program transformations in multithreaded Java, as defined by the Java Memory Model (JMM) section of Chapter 17 of the Java Language Specification. The main design goal of the JMM was to allow as many optimisations as possible. However, we find that commonly used optimisations, such as common subexpression elimination, can introduce new behaviours and so are invalid for Java. In this paper, we describe several kinds of transformations and explain the problems with a number of counterexamples. More positively, we also examine some valid transformations, and prove their validity. Our study contributes to the understanding of the JMM, and has the practical impact of revealing some cases where the Sun Hotspot JVM does not comply with the Java Memory Model. 1
Reasoning about Idealized Algol using regular languages
 In Proceedings of 27th International Colloquium on Automata, Languages and Programming ICALP 2000
, 2000
"... Abstract. We explain how recent developments in game semantics can be applied to reasoning about equivalence of terms in a nontrivial fragment of Idealized Algol (IA) by expressing sets of complete plays as regular languages. Being derived directly from the fully abstract game semantics for IA, our ..."
Abstract

Cited by 31 (11 self)
 Add to MetaCart
Abstract. We explain how recent developments in game semantics can be applied to reasoning about equivalence of terms in a nontrivial fragment of Idealized Algol (IA) by expressing sets of complete plays as regular languages. Being derived directly from the fully abstract game semantics for IA, our method of reasoning inherits its desirable theoretical properties. The method is mathematically elementary and formal, which makes it uniquely suitable for automation. We show that reasoning can be carried out using only a metalanguage of extended regular expressions, a language for which equivalence is formally decidable. Keywords: Game semantics, Algollike languages, regular languages 1
Games and full abstraction for nondeterministic languages
, 1999
"... Abstract Nondeterminism is a pervasive phenomenon in computation. Often it arises as an emergent property of a complex system, typically as the result of contention for access to shared resources. In such circumstances, we cannot always know, in advance, exactly what will happen. In other circumstan ..."
Abstract

Cited by 31 (3 self)
 Add to MetaCart
Abstract Nondeterminism is a pervasive phenomenon in computation. Often it arises as an emergent property of a complex system, typically as the result of contention for access to shared resources. In such circumstances, we cannot always know, in advance, exactly what will happen. In other circumstances, nondeterminism is explicitly introduced as a means of abstracting away from implementation details such as precise command scheduling and control flow. However, the kind of behaviours exhibited by nondeterministic computations can be extremely subtle in comparison to those of their deterministic counterparts and reasoning about such programs is notoriously tricky as a result. It is therefore important to develop semantic tools to improve our understanding of, and aid our reasoning about, such nondeterministic programs. In this thesis, we extend the framework of game semantics to encompass nondeterministic computation. Game semantics is a relatively recent development in denotational semantics; its main novelty is that it views a computation not as a static entity, but rather as a dynamic process of interaction. This perspective makes the theory wellsuited to modelling many aspects of computational processes: the original use of game semantics in modelling the simple functional language PCF has subsequently been extended to handle more complex control structures such as references and continuations.
Angelic semantics of finegrained concurrency
 In Proceedings of FOSSACS ’04, number 2987 in LNCS
, 2004
"... Abstract. We introduce a game model for a procedural programming language extended with primitives for parallel composition and synchronization on binary semaphores. The model uses an interleaved version of HylandOngstyle games, where most of the original combinatorial constraints on positions are ..."
Abstract

Cited by 27 (10 self)
 Add to MetaCart
Abstract. We introduce a game model for a procedural programming language extended with primitives for parallel composition and synchronization on binary semaphores. The model uses an interleaved version of HylandOngstyle games, where most of the original combinatorial constraints on positions are replaced with a simple principle naturally related to static process creation. The model is fully abstract for mayequivalence. 1 Introduction The two major paradigms of concurrent programming are messagepassing and sharedvariable. The latter style of programming is closer to the underlying machine model, which makes it both more popular and more "lowlevel " (and more errorprone) than the former. This constitutes very good motivation for the study of such languages. Concurrent sharedvariable programming languages themselves can come in several varieties: Finegrained languages have designated atomic actions which are implemented directly by the hardware on which the program is executed. In contrast, coarsegrained programming languages can specify sequences of actions to appear as indivisible. Languages with static process creation execute statements in parallel and
The RelyGuarantee Method for Verifying Shared Variable Concurrent Programs
, 1997
"... . Compositional proof systems for shared variable concurrent programs can be devised by including the interference information in the specifications. The formalism falls into a category called relyguarantee (or assumption commitment), in which a specification is explicitly (syntactically) split ..."
Abstract

Cited by 26 (0 self)
 Add to MetaCart
. Compositional proof systems for shared variable concurrent programs can be devised by including the interference information in the specifications. The formalism falls into a category called relyguarantee (or assumption commitment), in which a specification is explicitly (syntactically) split into two corresponding parts. This paper summarises existing work on the relyguarantee method and gives a systematic presentation. A proof system for partial correctness is given first, thereafter it is demonstrated how the relevant rules can be adapted to verify deadlock freedom and convergence. Soundness and completeness, of which the completeness proof is new, are studied with respect to an operational model. We observe that the relyguarantee method is in a sense a reformulation of the classical noncompositional Owicki & Gries method, and we discuss throughout the paper the connection between these two methods. 1 The research was partially supported by EspritBRA project 6021 (REACT)...
A Logical View Of Concurrent Constraint Programming
, 1995
"... . Concurrent Constraint Programming (CCP) has been the subject of growing interest as the focus of a new paradigm for concurrent computation. Like logic programming it claims close relations to logic. In fact CCP languages are logics in a certain sense that we make precise in this paper. In recent ..."
Abstract

Cited by 23 (4 self)
 Add to MetaCart
. Concurrent Constraint Programming (CCP) has been the subject of growing interest as the focus of a new paradigm for concurrent computation. Like logic programming it claims close relations to logic. In fact CCP languages are logics in a certain sense that we make precise in this paper. In recent work it was shown that the denotational semantics of determinate concurrent constraint programming languages forms a fibred categorical structure called a hyperdoctrine, which is used as the basis of the categorical formulation of firstorder logic. What this shows is that the combinators of determinate CCP can be viewed as logical connectives. In this paper we extend these ideas to the operational semantics of such languages and thus make available similar analogies for a much broader variety of languages including indeterminate CCP languages and concurrent blockstructured imperative languages. CR Classification: F3.1, F3.2, D1.3, D3.3 Key words: Concurrent constraint programming, simula...
Formal Methods for Component Software: The Refinement Calculus Perspective
 Proceedings of the Second Workshop on ComponentOriented Programming (WCOP), volume 5 of TUCS General Publication, pages 23–32, Short version in ECOOP’97 workshop reader LNCS 1357
, 1997
"... . We exhibit the benefits of using formal methods for constructing and documenting component software. Formal specifications provide concise and complete descriptions of blackbox components and, herewith, pave the way for full encapsulation. Specifications using abstract statements scale up bett ..."
Abstract

Cited by 21 (3 self)
 Add to MetaCart
. We exhibit the benefits of using formal methods for constructing and documenting component software. Formal specifications provide concise and complete descriptions of blackbox components and, herewith, pave the way for full encapsulation. Specifications using abstract statements scale up better than prepostconditions and allow for `relative' specifications because they may refer to other components. Nondeterminism in specifications permits enhancements and alternate implementations. A formally verifiable refinement relationship between specification and implementation of a component ensures compliance with the published specification. Unambiguous and complete contracts are the foundation of any component market. 1 Introduction The separation of specifications/interfaces and implementations of components is a prerequisite for the establishment of component software. It alleviates the necessity to distribute source code, thereby protects the implementation knowhow and avo...