Two of the most important issues in distributed systems are the synchronization of concurrent threads and the application-level data transfers between execution spaces. At the design level, addressing these issues typically requires analyzing the components under a different perspective than is required to analyze the functionality. Very often, it also involves analyzing several components at the same time, because of the way those two issues cross-cut the units of functionality. At the implementation level, existing programming languages fail to provide adequate support for programming in terms of these different and cross-cutting perspectives. The result is that the programming of synchronization and remote data transfers ends up being tangled throughout the components code in more or less arbitrary ways. This thesis presents a language framework called D that untangles the implementation of synchronization

We adopt the untyped imperative object calculus of Abadi and Cardelli as a minimal setting in which to study problems of compilation and program equivalence that arise when compiling objectoriented languages. We present both a big-step and a small-step substitution-based operational semantics for the calculus. Our rst two results are theorems asserting the equivalence of our substitutionbased semantics with a closure-based semantics like that given by Abadi and Cardelli. Our third result is a direct proof of the correctness of compilation to a stack-based abstract machine via a small-step decompilation algorithm. Our fourth result is that contextual equivalence of objects coincides with a form of Mason and Talcott's CIU equivalence; the latter provides a tractable means of establishing operational equivalences. Finally, we prove correct an algorithm, used in our prototype compiler, for statically resolving method osets. This is the rst study of correctness of an object-oriented abstract machine, and of operational equivalence for the imperative object calculus.

. This paper extends previous work in compiler derivation and verification to languages with true-concurrency semantics. We extend the -calculus to model process-centered concurrent computation, and give the semantics of a small language in terms of this calculus. We then define a target abstract machine whose states have denotations in the same calculus. We prove the correctness of a compiler for our language: the denotation of the compiled code is shown to be strongly bisimilar to the denotation of the source program, and the abstract machine running the compiled code is shown to be branching-bisimilar to the source program's denotation. 1 Introduction Our original goal was to verify a compiler for Linda [8], using that language as a representative of modern concurrent language design. Upon searching the literature, we found a vast amount of work on models of concurrency, but little that was obviously applicable to compiler derivation and verification. Accordingly we decided to tac...

This paper proposes a theoretical framework for verifying and deriving code optimizations for programs written in parallel programming languages. The key idea of this framework is to formalize code optimizations as compositional transformation rules for programs presented as terms of an enriched process calculus. The rules are formulated on the basis of an algebraic order relation between two programs which states that they are behaviorally equivalent and one of them is faster than the other. The correctness and e#ectiveness of optimized programs derived from the rules can be ensured in all circumstances. The framework is unique among other existing works in being able to quantitatively analyze the temporal costs of synchronizations among parallel programs. This paper presents basic ideas and definitions of the framework with several examples. 1. Introduction Parallel computation will play an increasingly important role in many areas of computer systems. As it becomes popular, custome...

In a series of papers in the early 80's we proposed a paradigm for semanticsbased compiler correctness. In this paradigm, the source and target languages are given denotational semantics in the same -theory, so correctness proofs can be carried out within this theory. In many cases, the proofs have a highly structured form. We show how a simple proof strategy, based on an algorithm for ff-matching, can be used to build a tool that can automate the routine cases of these proofs. 1 Introduction In a series of papers in the early 80's [19, 18, 20, 5] we proposed a paradigm for semantics-based compiler correctness, and over the last several years we have begun putting this paradigm into practice [22, 14]. In this paradigm, the source and target languages are given denotational semantics in the same -theory [11], so that most of the steps of the correctness proof can be done Work supported by the National Science Foundation under grant numbers CCR9014603 and CCR-9304144. within the t...

. Various mechanisms have been used for adapting functional languages to parallel machines, ranging from semantics--preserving annotations to concurrent language extensions. Concurrent extensions are applicable to both lazy and strict languages, and give the programmer full control over parallel evaluation; however, they complicate the proofs of program correctness. This paper pursues the concurrent extension approach to parallel functional programming, and addresses the question of proving parallel programs correct with respect to sequential specifications. The paper presents an extension of a lazy functional language with concurrency primitives, allowing the dynamic creation of processes and point--to--point interprocess communication. The primitives are given an operational semantics, and an observational equivalence between processes is defined. The equivalence has been implemented in a theorem prover for concurrent functional programs. As an illustration, the derivation of a para...

Abstract: In recent years there has been much interest in the idea of concurrent programming using transactional memory, for example as provided in STM Haskell. While programmers are provided with a simple high-level model of transactions in terms of a stop-the-world semantics, the low-level implementation is rather more complex, using subtle optimisation techniques to execute multiple concurrent transactions efficiently, which is essential to the viability of the programming model. In this article, we take the first steps towards a formally verified implementation of transactional memory. In particular, we present a stripped-down, idealised concurrent language inspired by STM Haskell, and show how a low-level implementation of this language can be justified with respect to a high-level semantics, by means of a compiler and its correctness theorem, mechanically tested using QuickCheck and the HPC (Haskell Program Coverage) toolkit. The use of these tools proved to be invaluable in the development of our formalisation.