doi:10.1016/j.tcs.2008.09.019 This is a PDF file of an unedited manuscript that has been accepted for publication. As a service to our customers we are providing this early version of the manuscript. The manuscript will undergo copyediting, typesetting, and review of the resulting proof before it is published in its final form. Please note that during the production process errors may be discovered which could affect the content, and all legal disclaimers that apply to the journal pertain. Manuscript

apport de recherche

This article presents an evolution of classical SPMD programming for clusters and grids.

Abstract not found

Abstract Asynchronous Active Objects (AAOs), primarily exempli ed by actors [1], nowadays exist in many forms (various kinds of actors, agents and components) and are more and more used because they t well the dynamic and asynchronous nature of interactions in many distributed systems. They raise various new issues regarding exception handling for which few operational solutions exist. More precisely, a need exists for a generic, simple and expressive, programmer level, exception handling system that appropriately handles the following main exception handling issues or requirements in the context of AAOs: encapsulation, object autonomy, coordination of concurrent collaborative entities [2], caller contextualization [3], asynchronous signaling and handler execution, resolution of concurrent exceptions [4,5], exception criticality [6] and object reactivity. This paper presents the speci cation of an evolution of the Sage exception handling system [7], which provides solutions to those issues in the context of systems developed with active objects using one way asynchronous communications and interacting via the request / response protocol. Such a context, in which synchronizations constraints are, when needed, handled at the application level, allows for a very generic view of what could be done regarding exception handling in all systems that use active objects. The Sage solution is original and provides a good compromise between expressive-power and simplicity.

Key words. Distributed systems, object-oriented programming, asynchronous method calls, type and effect systems, type soundness In the distributed setting, the object-oriented programming model may be criticized for its tight coupling of communication and synchronization, found in, e.g., remote procedure calls. Creol is a novel object-oriented language which targets distributed systems by combining asynchronous method calls with so-called processor release points inside concurrent objects [3]. A type system for Creol and a corresponding type soundness result is presented in [4]. Asynchronous method calls complicate the type analysis by decoupling input and output information for method calls, leading to a complex type and effect system [6] to track information during type analysis. Interestingly, the type system can be significantly simplified by backwards type analysis. In this paper, a type and effect system for backwards type analysis and a corresponding type soundness result are presented. We first give a brief summary of Creol’s concurrency and communication model. An object in Creol may be understood as an encapsulated state on which various processes are executed. A process corresponds to the activation of one of the object’s methods. Objects are

This paper introduces a new language model, Coqa, for deeply embedding concurrent programming into objects. Every program written in Coqa has the desir-able built-in behaviors of quantized atomicity, mutual exclusion, and race freedom. Such a design inverts the default mode of e.g. Java, where such properties have to be manually coded using primitive language constructs such as synchronized, result-ing in programs that are vulnerable to surprising run time errors. A key property of Coqa is the notion of quantized atomicity: all concurrent program executions can be viewed as being divided into quantum regions of atomic execution, greatly reducing the number of interleavings to consider. So rather than building atomicity locally, with small declared zones of atomicity, we build it globally, down from the top. We justify our approach from a theoretical basis by showing that a formal representation, KernelCoqa, has provable quantized atomicity properties. Then we extend Kernel-Coqa with two I/O models in which we conduct an in-depth study on how I/O affects the atomicity property and establish atomicity theorems with respect to I/O. We perform a series of benchmarks in CoqaJava, a Java-based prototype implementation ii incorporating all of the KernelCoqa features, to demonstrate the practicability of the Coqa model. We give concrete CoqaJava examples of various common concurrent programming patterns which showcase the strength and ease of programming of the language.

Abstract—UML 2 has introduced new diagrams for expressing hierarchical structures and their assembly, and has brought some new features to the behaviour-oriented diagrams (activities and state machines), that help modelling component systems. However, UML leaves many semantic decisions opened, and various emerging component frameworks also have features that cannot be directly expressed using UML 2 concepts. In this paper we present an approach for modelling two different component frameworks using UML 2 diagrams. First we define a mapping between the Fractal component model and UML 2 diagrams, and we describe CTTool, that allows to edit and model-check diagrams for Fractal components. Then we propose an extension of this work for the Grid Component Model, that is an extension of Fractal providing asynchronous, collective, and autonomic features for distributed component systems. Index Terms—software requirements engineering, software components, software reliability, grid computing This work is supported by the french ACI securité FIACRE, by the EC FP6 Streps project GridCOMP, and by the SticAmsud collaborative project Reseco.

Abstract. Invasive patterns are an extension of standard parallel and distributed architectural patterns for complex distributed algorithms. They have previously been implemented in terms of the AWED language, an aspect language with features for explicit distribution. In this paper we present two formal semantics based on labeled transition systems, one for AWED and the other for invasive patterns, for the definition of interaction properties of aspects and pattern compositions. We also show how the semantics can be used to check corresponding liveness and safety properties. 1

Abstract. Based on the impς-calculus, ASP (Asynchronous Sequential Processes) defines distributed applications behaving deterministically. This article extends ASP by building hierarchical and asynchronous distributed components. Components are hierarchical- a composite can be built from other components, and distributed- a composite can span over several machines. This article also shows how the asynchronous component model can be used to statically assert component determinism. The advent of components in programming technology raises the question of their formal ground, intrinsic semantics, and above all their compositional semantics. It represents a real challenge as practical component models are usually quite complex, featuring distribution over local or wide area networks. But, few formal models for component were proposed so far [4, 20, 3, 14]. Since the first ideas about software components, usually dated in 1968 [1], the design of a reusable piece of software has technically evolved. From the first off-the-shelf