Christian Pérez

GCM: a grid extension to Fractal for autonomous distributed components

This article presents an extension of the Fractal component model targeted at programming applications to be run on computing grids: the grid component model (GCM). First, to address the problem of deployment of components on the grid, deployment strategies have been defined. Then, as grid applications often result from the composition of a lot of parallel (sometimes identical) components, composition mechanisms to support collective communications on a set of components are introduced. Finally, because of the constantly evolving environment and requirements for grid applications, the GCM defines a set of features intended to support component autonomicity. All these aspects are developed in this paper with the challenging objective to ease the programming of grid applications, while allowing GCM components to also be the unit of deployment and management.

A Parallel Corba Component Model for Numerical Code Coupling

The fast growth of high bandwidth wide area networks has allowed the building of computational grids, which are constituted of PC clusters and/or parallel machines. Computational grids enable the design of new numerical simulation applications. For example, it is now feasible to couple several scientific codes to obtain a multi-physic application. In order to handle the complexity of such aplications, software component technology appears very appealing. However, most current software component models do not provide any support to transparently and efficiently embed parallel codes into components. This paper deals with GridCCM, an extension to the CORBA (Common Object Request Broker Architecture) Component Model to support parallel components. The feasibility of the model is evaluated thanks to its implementation on top of two CCM prototypes. Preliminary performance results are very good; there is no significant overhead while aggregating the network bandwidth capability of a parallel component.

Adding Virtualization Capabilities to the Grid’5000 Testbed

Almost ten years after its premises, the Grid’5000 testbed has become one of the most complete testbed for designing or evaluating large-scale distributed systems. Initially dedicated to the study of High Performance Computing, the infrastructure has evolved to address wider concerns related to Desktop Computing, the Internet of Services and more recently the Cloud Computing paradigm. This paper present recent improvements of the Grid’5000 software and services stack to support large-scale experiments using virtualization technologies as building blocks. Such contributions include the deployment of customized software environments, the reservation of dedicated network domain and the possibility to isolate them from the others, and the automation of experiments with a REST API. We illustrate the interest of these contributions by describing three different use-cases of large-scale experiments on the Grid’5000 testbed. The first one leverages virtual machines to conduct larger experiments spread over 4000 peers. The second one describes the deployment of 10000 KVM instances over 4 Grid’5000 sites. Finally, the last use case introduces a one-click deployment tool to easily deploy major IaaS solutions. The conclusion highlights some important challenges of Grid’5000 related to the use of OpenFlow and to the management of applications dealing with tremendous amount of data.

PadicoTM: an open integration framework for communication middleware and runtimes

Computational grids are seen as the future emergent computing infrastructures. Their programming requires the use of several paradigms that are implemented through communication middleware and runtimes. However some of these middleware systems and runtimes are unable to take benefit of specific networking technologies available in grid infrastructures. In this paper, we describe an open integration framework that allows several communication middleware and runtimes to efficiently share the networking resources. Such framework encourages grid programmers to use the most suited communication paradigms for their applications independently from the underlying networks. Therefore, there is no obstacle to deploy the applications on a specific grid configuration.

Generic application description model: toward automatic deployment of applications on computational grids

Computational grids promise to deliver a huge computer power as transparently as the electric power grid supplies electricity. Thus, applications need to be automatically deployed on computational grids. However, various types of applications may be run on a grid, so it may not be wise to design an automatic deployment tool for each specific programming model. This paper promotes a generic application description model which can express several specific application descriptions. Translating a specific application description into our generic description is a simple task. Then, developing new planning algorithms and re-using them for different application types will be much easier. Moreover, our generic description model allows to deploy applications based on a programming model combining several models, as parallel components encompass component-based and parallel programming models for instance. Our generic description model is implemented in an automatic deployment tool which can deploy CCM and MPICH-G2 applications.

Towards High Performance CORBA and MPI Middlewares for Grid Computing

Due to the high level of heterogeneity in a computational Grid, designing a runtime system for such computing infrastructure is extremely challenging, for example regarding the ability to exploit transparently and efficiently various networking technologies. Programming a computational Grid often requires the use of several communication paradigms (RPC, RMI, DSM, Message passing) that have to share these networking resources. This paper presents the first step towards a runtime system that allows efficient communication for various communication-oriented middlewares. We introduce a CORBA implementation that reaches 240 MB/s, which is as far as we know the best CORBA performance. Thus, CORBA can be as efficient as MPI on high performance networks. Moreover, we show that different communication middlewares, like CORBA and MPI, can efficiently co-habit within the same runtime system taking full benefit of various networking resources (SAN to WAN).

PACO++: a parallel object model for high performance distributed systems

The availability of high bandwidth wide area networks enables the coupling of several computing resources - supercomputers or PC clusters - together to obtain a high performance distributed system. The question is to determine a suitable programming model that provides transparency, interoperability, reliability, scalability and performance. Since such systems appear as a combination of distributed and parallel systems, it is tempting to extend programming models that were associated to distributed or to parallel systems. Another choice is to combine the two different worlds into a single coherent one. A parallelism oriented model appears more adequate to program parallel codes while a distributed oriented model is more suitable to handle inter-code communications. This issue is addressed with the concept of parallel object. We have applied it to Corba so as to define a parallel Corba object: it is a collection of identical Corba objects with a single program multiple data (SPMD) execution model. This paper presents PACO++, a portable implementation of the concept of parallel Corba object. It examines how the different design issues have been tackled with. For example, scalability is achieved between two parallel Corba objects by involving all members of both collections in the communication: an aggregated bandwidth of 874 Mbit/s has been obtained on a 1 Gbit/s WAN. Such a performance is obtained while preserving the semantics of Corba and in particular interoperability with standard Corba objects.

A network topology description model for grid application deployment

Computational grids are probably among the most heterogeneous computing systems. However, they are very attractive for their potential computational power. Their heterogeneity is especially perceptible during the deployment of grid applications. In particular, an automatic and efficient deployment of grid applications on resources requires to have access to the characteristics of the resources. This paper presents a description model of (grid) networks which provides a functional view of the network topology. The simplicity of the proposed model does not hinder the description of complex network topologies (asymmetric links, firewalls, nonIP networks, nonhierarchical topologies).

Deploying CORBA components on a computational grid: General principles and early experiments using the globus toolkit

The deployment of high bandwidth wide-area networks has led computational grids to offer a very powerful computing resource. In particular, this inherently distributed resource is well-suited for multiphysics applications. To face the complexity of such applications, the software component technology appears to be a very adequate programming model. However, to take advantage of the computational power of grids, component-based applications should be automatically deployed in computational grids. Based on the Corba component specifications for the deployment of components, which seem to currently be the most complete, this paper proposes a detailed process for component deployment in computational grids. It also reports on early experiments on deploying Corba components in a computational grid using the Globus Toolkit 2.4.

A Parallel CORBA Component Model for Numerical Code Coupling

The fast growth of high bandwidth wide area networks has allowed the building of computational grids, which are constituted of PC clusters and/or parallel machines. Computational grids enable the design of new numerical simulation applications. For example, it is now feasible to couple several scientific codes to obtain a multi-physic application. In order to handle the complexity of such applications, software component technology appears very appealing. However, most current software component models provide no support to transparently and efficiently embed parallel codes into components. This paper describes a first study of GridCCM, an extension to the CORBA Component Model to support parallel components. The feasibility of the model is evaluated thanks to its implementation on top of two CCM prototypes. Preliminary performance results show that bandwidth is efficiently aggregated.