Results 1  10
of
21
Transactional Events
, 2008
"... Concurrent programs require highlevel abstractions in order to manage complexity and enable compositional reasoning. In this paper, we introduce a novel concurrency abstraction, dubbed transactional events, which combines firstclass synchronous message passing events with allornothing transactio ..."
Abstract

Cited by 33 (1 self)
 Add to MetaCart
Concurrent programs require highlevel abstractions in order to manage complexity and enable compositional reasoning. In this paper, we introduce a novel concurrency abstraction, dubbed transactional events, which combines firstclass synchronous message passing events with allornothing transactions. This combination enables simple solutions to interesting problems in concurrent programming. For example, guarded synchronous receive can be implemented as an abstract transactional event, whereas in other languages it requires a nonabstract, nonmodular protocol. As another example, threeway rendezvous can be implemented as an abstract transactional event, which is impossible using firstclass events alone. Both solutions are easy to code and easy to reason about. The expressive power of transactional events arises from a sequencing combinator whose semantics enforces an allornothing transactional property – either both of the constituent events synchronize in sequence or neither of them synchronizes. This sequencing combinator, along with a nondeterministic choice combinator, gives transactional events the compositional structure of a monadwithplus. We provide a formal semantics for transactional events and give a detailed account of an implementation.
Typed closure conversion preserves observational equivalence
, 2008
"... Languagebased security relies on the assumption that all potential attacks are bound by the rules of the language in question. When programs are compiled into a different language, this is true only if the translation process preserves observational equivalence. We investigate the problem of fully ..."
Abstract

Cited by 17 (4 self)
 Add to MetaCart
Languagebased security relies on the assumption that all potential attacks are bound by the rules of the language in question. When programs are compiled into a different language, this is true only if the translation process preserves observational equivalence. We investigate the problem of fully abstract compilation, i.e., compilation that both preserves and reflects observational equivalence. In particular, we prove that typed closure conversion for the polymorphic λcalculus with existential and recursive types is fully abstract. Our proof uses operational techniques in the form of a stepindexed logical relation and construction of certain wrapper terms that “backtranslate ” from target values to source values. Although typed closure conversion has been assumed to be fully abstract, we are not aware of any previous result that actually proves this.
Transactional events for ML
 In ICFP’08: International Conference on Functional Programming
, 2008
"... Transactional events (TE) are an approach to concurrent programming that enriches the firstclass synchronous messagepassing of Concurrent ML (CML) with a combinator that allows multiple messages to be passed as part of one allornothing synchronization. Donnelly and Fluet (2006) designed and impl ..."
Abstract

Cited by 10 (1 self)
 Add to MetaCart
Transactional events (TE) are an approach to concurrent programming that enriches the firstclass synchronous messagepassing of Concurrent ML (CML) with a combinator that allows multiple messages to be passed as part of one allornothing synchronization. Donnelly and Fluet (2006) designed and implemented TE as a Haskell library and demonstrated that it enables elegant solutions to programming patterns that are awkward or impossible in CML. However, both the definition and the implementation of TE relied fundamentally on the code in a synchronization not using mutable memory, an unreasonable assumption for mostly functional languages like ML where functional interfaces may have impure implementations. We present a definition and implementation of TE that supports MLstyle references and nested synchronizations, both of which were previously unnecessary due to Haskell’s more restrictive type system. As in prior work, we have a highlevel semantics that makes nondeterministic choices such that synchronizations succeed whenever possible and a lowlevel semantics that uses search to implement the highlevel semantics soundly and completely. The key design tradeoff in the semantics is to allow updates to mutable memory without requiring the implementation to consider all possible thread interleavings. Our solution uses firstclass heaps and allows interleavings only when a message is sent or received. We have used Coq to prove the high and lowlevel semantics equivalent. We have implemented our approach by modifying the Objective Caml runtime system. By modifying the runtime system, rather than relying solely on a library, we can eliminate the potential for nonterminating computations within unsuccessful synchronizations to run forever.
A Model of Cooperative Threads
"... We develop a model of concurrent imperative programming with threads. We focus on a small imperative language with cooperative threads which execute without interruption until they terminate or explicitly yield control. We define and study a tracebased denotational semantics for this language; this ..."
Abstract

Cited by 10 (2 self)
 Add to MetaCart
We develop a model of concurrent imperative programming with threads. We focus on a small imperative language with cooperative threads which execute without interruption until they terminate or explicitly yield control. We define and study a tracebased denotational semantics for this language; this semantics is fully abstract but mathematically elementary. We also give an equational theory for the computational effects that underlie the language, including thread spawning. We then analyze threads in terms of the free algebra monad for this theory. 1
A Fully Abstract Semantics for a HigherOrder Functional Language With Nondeterministic Computation
, 1994
"... . This paper is about the relationship between the theory of monadic types and the practice of concurrent functional programming. We present a typed functional programming language CMML, with a type system based on Moggi's monadic metalanguage, and concurrency based on Reppy's Concurrent ..."
Abstract

Cited by 9 (3 self)
 Add to MetaCart
. This paper is about the relationship between the theory of monadic types and the practice of concurrent functional programming. We present a typed functional programming language CMML, with a type system based on Moggi's monadic metalanguage, and concurrency based on Reppy's Concurrent ML. We present an operational and denotational semantics for the language, and show that the denotational semantics is fully abstract for maytesting. We show that a fragment of CML can be translated into CMML, and that the translation is correct up to weak bisimulation. Contents 1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 2 Mathematical preliminaries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 2.1 Categories and monads . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 2.2 Partial orders . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ....
Full Abstractness for a Functional/Concurrent Language With HigherOrder ValuePassing
, 1998
"... We study an applied typed callbyvalue calculus which in addition to the usual types for higherorder functions contains an extra type called proc, for processes. The constructors for terms of this type are similar to those found in standard process calculi such as CCS. We first give an operationa ..."
Abstract

Cited by 6 (2 self)
 Add to MetaCart
We study an applied typed callbyvalue calculus which in addition to the usual types for higherorder functions contains an extra type called proc, for processes. The constructors for terms of this type are similar to those found in standard process calculi such as CCS. We first give an operational semantics for this language in terms of a labelled transition system which is then used to give a behavioural preorder based on contexts: the expression N dominates M if in every appropriate context if M can produce a boolean value then so can N. Based on standard domain constructors we define a model, a prime algebraic lattice, which is fully abstract with respect to this behaviour preorder.
Semantics for core Concurrent ML using computation types
 Higher Order Operational Techniques in Semantics, Proceedings
, 1997
"... This paper presents two typed higherorder concurrent functional programming languages, based on Reppy's Concurrent ML. The first is a simplified, monomorphic variant of CML, which allows reduction of terms of any type. The second uses an explicit type constructor for computation, in the style ..."
Abstract

Cited by 6 (0 self)
 Add to MetaCart
This paper presents two typed higherorder concurrent functional programming languages, based on Reppy's Concurrent ML. The first is a simplified, monomorphic variant of CML, which allows reduction of terms of any type. The second uses an explicit type constructor for computation, in the style of Moggi's monadic metalanguage. Each of these languages is given an operational semantics, which can be used as the basis of bisimulation equivalence. We show how Moggi's translation of the callbyvalue lambdacalculus into the mondadic metalanguage can be extended to these concurrent languages, and that this translation is correct up to weak bisimulation. 1 Introduction Reppy's (1991, 1992) Concurrent ML is an extension of New Jersey ML with features for spawning threads, which can communicate by onetoone synchronous handshake in the style of Milner's (1989) CCS. There are (at least) two approaches to giving the operational semantics to CML. The `functional language definition' tradition (Mi...
A behavioural theory of firstorder CML
, 1999
"... We investigate a number of semantic issues which arise, when a language of expressions such as ML, is augmented with constructs for communication and concurrency, as is the case with CML. We construct a simple language of firstorder expressions, which includes an operator let.. =...in...end to prov ..."
Abstract

Cited by 4 (0 self)
 Add to MetaCart
We investigate a number of semantic issues which arise, when a language of expressions such as ML, is augmented with constructs for communication and concurrency, as is the case with CML. We construct a simple language of firstorder expressions, which includes an operator let.. =...in...end to provide a form of sequentialisation and a simple form of abstraction, communication constructs, and a spawn operator, for expressing concurrency. We construct an operational semantics for the language, which ensures that a number of natural laws for the let operator hold. In addition we provide a testing semantics for the language, and show how a fully abstract model for the resulting testing preorder, can be constructed from a variation of
An EquivalencePreserving CPS Translation via MultiLanguage Semantics (Technical Appendix)
"... the complete set of technical definitions (Sections 3 to 7), and the proofs (Sections 8 to 13). In particular, in Section 1.3, we adopt System F without the CPS restriction as our target language and present the changes needed—to the backtranslation and the proofs—to establish full abstraction in t ..."
Abstract

Cited by 3 (0 self)
 Add to MetaCart
the complete set of technical definitions (Sections 3 to 7), and the proofs (Sections 8 to 13). In particular, in Section 1.3, we adopt System F without the CPS restriction as our target language and present the changes needed—to the backtranslation and the proofs—to establish full abstraction in this setting.
Languages, Theory
"... We develop a model of concurrent imperative programming with threads. We focus on a small imperative language with cooperative threads which execute without interruption until they terminate or explicitly yield control. We define and study a tracebased denotational but mathematically elementary. We ..."
Abstract
 Add to MetaCart
We develop a model of concurrent imperative programming with threads. We focus on a small imperative language with cooperative threads which execute without interruption until they terminate or explicitly yield control. We define and study a tracebased denotational but mathematically elementary. We also give an equational theory for the computational effects that underlie the language, including thread spawning. We then analyze threads in terms of the free algebra monad for this theory.