Denis Caromel

Programming, Composing, Deploying for the Grid

Grids raise new challenges in the following way: heterogeneity of underlying machines/networks and runtime environments (types and performance characteristics), not a single administrative domain, versatility. So the need to have appropriate programming and runtime solutions in order to write, deploy then execute applications on such heterogeneous distributed hardware in an effective and efficient manner. We propose in this article a solution to those challenges which takes the form of a programming and deployment framework featuring parallel, mobile, secure and distributed objects and components.

Partial behavioral reflection: spatial and temporal selection of reification

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.

Peer-to-peer for computational grids: mixing clusters and desktop machines

This paper presents a Peer-to-Peer (P2P) infrastructure that supports a large scale grid. The P2P infrastructure is implemented in Java and federates Java Virtual Machines (JVMs) for computation. The management of shared JVMs is decentralized, self-organized, and configurable. The P2P infrastructure was deployed as a permanent desktop grid, with which we have achieved a computation record by solving the NQueens problem for 25 queens. Thereafter, we have mixed this desktop grid with five highly heterogeneous clusters from the Grid5000 platform. We analyze the behavior of this thousand CPU grid with two communicating applications: NQueens and Flow-Shop.

Collective Interfaces for Distributed Components

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.

Peer-to-Peer and fault-tolerance: Towards deployment-based technical services

For effective components, non-functional aspects must be added to application functional code. Likewise, enterprise middleware and component platforms, in the context of Grids, services must be deployed at execution in component containers in order to implement those aspects without modifications in the application code. This paper proposes an architecture for defining, configuring, and deploying such Technical Services in a Grid platform.

On Hierarchical, Parallel, and Distributed Components for Grid Programming

We propose a parallel and distributed component model for building applications adapted to the hierarchical, highly distributed, highly heterogeneous nature of Grids. Instead of featuring a flat assembly model as for instance in the CCM and CCA models, we claim that a hierachical assembly model should ease the building and dynamic reconfiguration of component oriented Grid applications. The proposed model and associated framework is based on ProActive, a middleware (programming model and environment) for object oriented parallel, mobile, and distributed computing. We have extended ProActive by implementing a hierarchical and dynamic component model, named Fractal, so as to master the complexity and scalability of composition and deployment. This defines a concept of components for the Grid: primitive or composite, made of several activities, parallel and distributed. Components communicate using typed one-to-one or collective invocations on interfaces. Composition of interfaces and of other properties such as the one pertaining to the deployment of components are specifically addressed.

Sequential object monitors

Programming with Java monitors is recognized to be difficult, and potentially inefficient due to many useless context switches induced by the notifyAll primitive. This paper presents SOM, Sequential Object Monitors, as an alternative to programming with Java monitors.

Asynchronous typed object groups for grid programming

This article presents an object-oriented mechanism to achieve group communication in large scale grids. Group communication is a crucial feature for high-performance and grid computing. While previous work on collective communications imposed the use of dedicated interfaces, we propose a scheme where one can initiate group communications using the standard public methods of the class by instantiating objects through a special object factory. The object factory utilizes casting and introspection to construct a “parallel processing enhanced” implementation of the object which matches the original class’ interface. This mechanism is then extended in an evolution of the classical SPMD programming paradigm into the domain of clusters and grids named “Object-Oriented SPMD”. OOSPMD provides interprocess (inter-object) communications via transparent remote method invocations rather than custom interfaces. Such typed group communication constitutes a basis for improvement of component models allowing advanced composition of parallel building blocks. The typed group pattern leads to an interesting, uniform, and complete model for programming applications intended to be run on clusters and grids.

Latency based group discovery algorithm for network aware cloud scheduling

Cloud computing is a big paradigm shift of computing mechanism. It provides high scalability and elasticity with a range of on-demand services. We can execute a variety of distributed applications on clouds virtual machines (computing nodes). In a distributed application, virtual machine nodes need to communicate and coordinate with each other. This type of coordination requires that the inter-node latency should be minimal to improve the performance. But in the case of nodes belonging to different clusters of the same cloud or in a multi-cloud environment, there can be a problem of higher network latency. So it becomes more difficult to decide, which node(s) to choose for the distributed application execution, to keep inter-node latency at minimum. In this paper, we propose a solution for this problem. We propose a model for the grouping of nodes with respect to network latency. The application scheduling is done on the basis of network latency. This model is a part of our proposed Cloud Scheduler module, which helps the scheduler in scheduling decisions on the basis of different criteria. Network latency and resultant node grouping on the basis of this latency is one of those criteria. The main essence of the paper is that our proposed latency grouping algorithm not only has no additional network traffic overheads for algorithm computation but also works well with incomplete latency information and performs intelligent grouping on the basis of latency. This paper addresses an important problem in cloud computing, which is locating communicating virtual machines for minimum latency between them and group them with respect to inter-node latency.

Optimizing Metacomputing with Communication-Computation Overlap

In the framework of distributed object systems, this paper presents the concepts and an implementation of an overlapping mechanism between communication and computation. This mechanism allows to decrease the execution time of a remote method invocation with parameters of large size. Its implementation and related experiments in the C++// language running on top of Globus and Nexus are described.