Summary form only given. This talk (modestly) attend to address challenges and opportunities ahead of us for making parallel programming as efficient, as productive, as effective as possible, on both Multi-cores and large-scale infrastructures such as Grids and Clouds. We draw on our experience at simplifying the programming of applications that are distributed on local area network (LAN), on cluster of workstations, or GRIDs, and of course, Clouds. We will discuss a specific approach, Network On Ship, to cope seamlessly with both distributed and shared-memory multi-core machines. The point will be illustrated with ProActive an Open Source library for parallel, distributed, and concurrent computing, allowing to showcase interactive and graphical GUI and tools. Benchmarks on platforms such as Grid 5000, together with standardization and collaboration with Chinese partners will also be reported.

The master/worker API of the ProActive middleware provides with an easy way to use framework for parallelizing embarrassingly parallel applications. However, the traditional master/worker model faces great challenges as the development of the scalability of the distributed computing. A single-layer hierarchical master/worker has been implemented as a solution to the scalability issues of the MW API. In the new framework, the mainmaster only communicates with some submasters, and each submaster manages a set of workers. A ldquobully election algorithmrdquo and an ldquoobject discovery mechanismrdquo are implemented to solve the fault-tolerance problems of the submasters. An automatic load-balancing mechanism is implemented for the hierarchical master/worker to solve divisible tasks. Moreover, an optimization has been done to make the fault-tolerance mechanism more efficient.

We will share or experience at simplifying the programming of applications that are distributed on local area network (LAN), on cluster of workstations, or grids, and of course, clouds. We will promote a kind of approach, network on chip, to cope seamlessly with both distributed and shared-memory multi-core machines. A theoretical foundation ensures constant behavior, whatever the environment.

Genetic algorithms are very demanding in terms of computing time and, when the population size is large, they need days to complete or even fail due to memory restrictions. It is particularly the case for artificial life where each evaluation can take more than one minute to develop an artificial creature, plant or organism. Indeed, creatures are developed in physical and chemical simulators that require important computation resources. In order to create more and more realistic creatures, we propose a grid parallelized version of genetic algorithms. Two possibilities exist to increase them: supercomputers or computational grids. Because of their scalability, we choose computational grid in their works.

About ten years after the Java Grande effort, this paper aims at providing a snapshot of the comparison of Fortran MPI, with Java performance for parallel computing, using the ProActive library. We first analyze some performance details about ProActive behaviors, and then compare its global performance from the MPI library. This comparative is based on the five kernels of the NAS parallel benchmarks. From those experiments we identify benchmarks where parallel Java performs as well as Fortran MPI, and lack of performance on others, together with clues for improvement.

A file data model for algorithmic skeletons is proposed, focusing on transparency and efficiency. Algorithmic skeletons correspond to a high-level programming model that takes advantage of nestable programming patterns to hide the complexity of parallel/distributed applications. Transparency is achieved using a workspace factory abstraction and the proxy pattern to intercept calls on File type objects. Thus allowing programmers to continue using their accustomed programming libraries, without having the burden of explicitly introducing non-functional code to deal with the distribution aspects of their data. A hybrid file fetching strategy is proposed (instead of lazy or eager), that takes advantage of annotated functions and pipelined multithreaded interpreters to transfer files in-advance or on-demand. Experimentally, using a BLAST skeleton application, it is shown that the hybrid strategy provides a good tradeoff between bandwidth usage and CPU idle time.

ProActive is a Java library (Source code under GPL license) for parallel, distributed, and concurrent computing, also featuring mobility and security in a uniform framework. ProActive aimed at simplifying the programming of applications that are distributed on Local Area Network (LAN), on cluster of workstations, or large scale Grids. ProActive promotes a strong NoC approach, Network On Ship, to cope seamlessly with both distributed and shared-memory multi-core machines. A theoretical foundation ensures constant behavior, whatever the environment.ProActive features location tracking of moving objects, together with a strong programming model that makes it very suitable for global computinginfrastructure.Interactive and graphical GUI of the ProActive Parallel Suite will also be presented during the talk.

This paper addresses the issue of type safe algorithmic skeletons. From a theoretical perspective we contribute by: formally specifying a type system for algorithmic skeletons, and proving that the type system guarantees type safety. From an implementation point of view, we show how it is possible to enforce the type system on an Java based algorithmic skeleton library. The enforcement takes place at the composition of the skeleton program, by typing each skeleton with respect to its construction parameters: sequential functions, and other skeletons. As a result, hierarchical skeleton nesting can be performed safely, since type errors can be detected by the skeleton type system.

Abstract Coordination of parallel activities on a shared memory machine is a crucial issue for modern software, even more with the advent of multi‐core processors. Unfortunately, traditional concurrency abstractions force programmers to tangle the application logic with the synchronization concern, thereby compromising understandability and reuse, and fall short when fine‐grained and expressive strategies are needed. This paper presents a new concurrency abstraction called POM,parallel object monitor, supporting expressive means for coordination of parallel activities over one or more objects, while allowing a clean separation of the coordination concern from application code. Expressive and reusable strategies for concurrency control can be designed, thanks to a full access to the queue of pending requests, parallel execution of dispatched requests together with after‐actions, and complete control over reentrancy. A small domain‐specific aspect language is provided to adequately configure pre‐packaged, off‐the‐shelf synchronizations. Copyright © 2007 John Wiley & Sons, Ltd.

We propose to address collective communications in distributed components through collective interfaces. Collective interfaces handle data distribution, parallelism and synchronization, and they expose collective behaviors in the definition of components. We show, as an illustration, that collective interfaces allow the encoding of SPMD programming in a better structured and less error prone way. We verify the scalability and performance of collective interfaces in an experiment on up to 100 machines.

While many dream and talk about service level agreement (SM) and quality of service (QoS) for service oriented architectures (SOA), the practical reality of grid computing are still far from providing effective techniques enabling such contractual agreements. Towards this goal, this paper provides an overview of the techniques offered by ProActive to set and use contractual agreements. Based on the identification of roles, application developer, infrastructure manager, application user, the actors of a grid environment can specify what is required or what is provided at various levels. The results are both flexibility and adaptability, matching the application constraints and the environment characteristics with various techniques.

Component-based development has emerged as an effective approach to building flexible systems, but there is little experience in applying this approach to grid programming. This paper presents our experience with reengineering a high performance numerical solver to become a component-based grid application. The adopted component model is an extension of the generic fractal model that specifically targets grid environments. The paper provides qualitative and quantitative evidence that componentisation has improved the modifiability and reusability of the application while not significantly affecting performance.

No abstract available.

This article presents an evolution of classical SPMD programming for clusters and grids. It is named "object-oriented SPMD" as it is based on remote method invocation. More precisely, it is based on an active object pattern, extended as a typed group of active objects, to which SPMD's specificities are added. The proposed programming model is more flexible: techniques to postpone barrier and to remove any explicit loop make it possible to privilege reactivity and reuse. The resulting OO-SPMD API has been implemented in ProActive. Good scalability and quite competitive performances, compared to what is obtained using C-MPI, are demonstrated.

Summary form only given. Within the trend of object-based distributed computing, we present the design and implementation of a numerical simulation for electromagnetic waves propagation. A sequential Java design and implementation is first presented. Further, a distributed and parallel version is derived from the first, using an active object pattern. In addition, benchmarks are presented on this nonembarrassingly parallel application. A first contribution resides in the sequential object-oriented design that proved to be very modular and extensible; the classes and abstractions are designed to allow both element and volume type methods, furthermore, valid on structured, unstructured, or hybrid meshes. Compared to a Fortran version, the performance of this highly modular version proved to be in the same range. It is also shown how smoothly the sequential version can be distributed, keeping the same structuring and object abstractions, allowing to deal with larger data size. Finally, benchmarks on up to 64 processors compare the performances with respect to sequential and parallel versions, putting that in perspective with a comparable Fortran version.

This paper aims at providing confluence and determinism properties in concurrent processes, more specifically within the paradigm of object-oriented systems. Such results should allow one to program parallel and distributed applications that behave in a deterministic manner, even if they are distributed over local or wide area networks. For that purpose, an object calculus is proposed. Its key characteristics are asynchronous communications with futures, and sequential execution within each process.While most of previous works exhibit confluence properties only on specific programs -- or patterns of programs, a general condition for confluence is presented here. It is further put in practice to show the deterministic behavior of a typical example.

Previous experiments with high-performance Java were initially disappointing. After several years of optimization, this paper investigates the current suitability of such object-oriented middle-ware for High-Performance and Grid programming. Using a middleware o®ering high level abstractions (ProActive), we have replaced the standard Java RMI layer with the optimized Ibis RMI interface. Ibis is a grid programming environment featuring e±cient communications. Using a 3D electromagnetic application (an object-oriented time domain ¯nite volume solver for 3D Maxwell equations) we have ¯rst conducted benchmarks on single clusters, including comparisons with the same application in Fortran MPI. Finally, Grid experiments have been conducted simultaneously on up to 5 di®erent clusters. Overall, the paper reports extremely promising results. For instance, a speed up of 12 on 16 machines (vs. 13.8 for Fortran), a speedup of 100 on 150 machines on a Grid. 1

Behavioral reflection is a powerful approach for adapting the behavior of running applications. In this paper we present and motivate partial behavioral reflection, an approach to more efficient and flexible behavioral reflection. We expose the spatial and temporal dimensions of such reflection, and propose a model of partial behavioral reflection based on the notion of hooksets. In the context of Java, we describe a reflective architecture offering appropriate interfaces for static and dynamic configuration of partial behavioral reflection at various levels, as well as Reflex, an open reflective extension for Java implementing this architecture. Reflex is the first extension that fully supports partial behavioral reflection in a portable manner, and that seamlessly integrates load-time and runtime behavioral reflection. The paper shows preliminary benchmarks and examples supporting the approach. The examples, dealing with the observer pattern and asynchronous communication via transparent futures, also show the interest of partial behavioral reflection as a tool for open dynamic Aspect-Oriented Programming.

Abstract The advent of component‐based reflective applications raises the issue of protecting baselevel components from the actions performed by metalevel components. However, by their very nature, reflective applications are far more difficult to secure than non‐reflective applications, which certainly explains why the problem has received very little attention so far. In this paper we present a security framework for enforcing access control between metalevel components and the baselevel components they reflect on. Rather than designing a new security architecture from scratch, we extend the standard security architecture of Java to provide security for a fully‐functional proxy‐based MOP for Java. We implement a number of well‐known meta‐level behaviors and study their security requirements, the results of which support our design choices. Copyright © 2003 John Wiley & Sons, Ltd.

Increasing complexity of distributed applications and commodity of resources through grids are making the tasks of deploying those applications harder. There is a clear need for standard tools allowing versatile deployment and analysis of distributed applications. We present here a solution for the deployment and monitoring of applications written using ProActive, an experimental Java-based library for concurrent, distributed and mobile computing. We describe the use of XML-based descriptor for the deployment part of a distributed application and the use of IC2D (Interactive Control and Debugging of Distribution), for the monitoring and steering of the running application. Those ideas, concepts, and experiments are a contribution towards the construction of integrated environments for component-based grid programming.

Proposes a flow-sensitive, context-insensitive alias analysis in Java that is more efficient and precise than previous analyses in C++. For this, we propose a reference-set alias representation and we present the propagation rules for this representation. For the type determination, the type table is built with reference variables and with all possible types of those variables. We propose an algorithm in a popular iterative loop method with a structural traversal of a context-free grammar. Finally, we show that our reference-set representation has better performance for the alias analysis algorithm than the existing object-pair representation does.

Due to its platform-independent execution model, its support for networking, multithreading and mobile code, Java has given hope that easy Internet-wide high-performance network computing was at hand. Numerous attempts have then been made at providing a framework for the development of such metacomputing applications. Unfortunately, none of them addresses seamless sequential, multithreaded and distributed computing, i.e. the execution of the same application on a multiprocessor shared-memory machine as well as on a network of workstations, or on any hierarchical combination of both. In this paper we first identify four requirements for the development of such metacomputing frameworks. We then introduce Java// (pronounced Java Parallel), a 100% Java library that provides transparent remote objects as well as asynchronous two-way calls, high reuse potential and high-level synchronization mechanisms. We also present the metaobject protocol (MOP) Java// is built on and describe a distributed collaborative raytracing test application built using Java//. © 1998 John Wiley & Sons, Ltd.

We present a graphical environment for parallel object-oriented programming. It provides visual tools to develop and debug object-oriented programs as well as parallel or concurrent systems. This environment was derived from a structural operational semantics of an extension of the Eiffel language, Eiffel//. Object-related features of the language (inheritance, polymorphism) are formalized using a big-step semantics, while the interleaving model of concurrency is expressed with small-step semantics.Without user instrumentation, the interactive environment proposes features such as step-by-step animated executions, graphical visualization of object and process topology, futures and pending requests, control of interleaving, deadlock detection.

This article formally defines Eiffel dynamic binding in presence of renaming and redefinition. Message passing, inheritance, and polymorphism are expressed in an operational style using natural semantics. From the formal specification, we derive an algorithm to determine the appropriate version of a feature to apply to a given object. This algorithm, based only on the class hierarchy and not using any intermediate structure, gives a practical approach to the understanding of inheritance, renaming, and redefinition in Eiffel.