References of "de Marneffe, Pierre-Arnoul"
     in
Bookmark and Share    
Full Text
Peer Reviewed
See detailLattice Boltzmann Simulation Code Optimization Based on Constant-time Circular Array Shifting
Dethier, Gérard ULg; de Marneffe, Pierre-Arnoul ULg; Marchot, Pierre ULg

in Procedia Computer Science (2011), 4

Lattice Boltzmann (LB) methods are a class of Computational Fluid Dynamics (CFD) methods for fluid flow simulation. LB simulation codes have high requirements regarding memory and computational power ... [more ▼]

Lattice Boltzmann (LB) methods are a class of Computational Fluid Dynamics (CFD) methods for fluid flow simulation. LB simulation codes have high requirements regarding memory and computational power: they may involve the update of several millions of floating point values thousands of times and therefore require several gigabytes of available memory and run for several days. Optimized implementations of LB methods minimize these requirements. An existing method based on a particular data layout and an associated implementation implying a constant time array shifting allows to reduce the execution time of LB simulations and almost minimize memory usage when compared to a naive implementation. In this paper, we show that this method can be further improved, both in memory usage and performances by slightly modifying the data layout and by using blocking in order to enhance data locality. [less ▲]

Detailed reference viewed: 139 (8 ULg)
Full Text
Peer Reviewed
See detailP2P File Sharing for P2P Computing
Briquet, Cyril ULg; Dalem, Xavier ULg; Jodogne, Sébastien ULg et al

in Multiagent and Grid Systems (2009), 2009/5(2), 137-164

The transfer of large input data files in P2P computing Grids often leads to delays in Task completion times. Existing research related to this topic has been focused on the spatial grouping of Tasks, i.e ... [more ▼]

The transfer of large input data files in P2P computing Grids often leads to delays in Task completion times. Existing research related to this topic has been focused on the spatial grouping of Tasks, i.e. reuse of available data through data caching and data-aware scheduling. However, it tends to decrease the level of parallelism of Task execution. In this paper, this issue is addressed by integrating the BitTorrent P2P file sharing protocol, a novel Task selection scheduling algorithm, an existing online, data-aware Resource selection algorithm (similar to Storage Affinity), and caching support. These algorithms have been implemented in the Lightweight Bartering Grid middleware. The Java implementation relies exclusively on Free and Open Source data transfer software (Azureus, Apache FTP server, edtFTPj). The proposed data transfer architecture does not need Predictive Communications Ordering or an explicit deployment of an overlay network. It is also easily deployable. Our main contribution is the joint use of P2P computing and P2P file sharing technologies, enabling a highly scalable and adaptive data transfer architecture to support P2P computing. [less ▲]

Detailed reference viewed: 435 (30 ULg)
Full Text
Peer Reviewed
See detailDistributed Dynamic Load Balancing for Iterative-Stencil Applications
Dethier, Gérard ULg; Marchot, Pierre ULg; de Marneffe, Pierre-Arnoul ULg

in Cracow Grid Workshop '08 Proceedings (2009, March)

In the context of jobs executed on heterogeneous clusters or Grids, load balancing is essential. Indeed, a slow machine must receive less work than a faster one otherwise the overall job termination will ... [more ▼]

In the context of jobs executed on heterogeneous clusters or Grids, load balancing is essential. Indeed, a slow machine must receive less work than a faster one otherwise the overall job termination will be delayed. This is particularly true for Iterative-Stencil Applications where tasks are run simultaneously and are interdependent. The problem of assigning coexisting tasks to machines is called mapping. With dynamic clusters (where the number of machines and their available power can change over time), dynamic mapping must be used. A new mapping must be calculated each time the cluster changes. The mapping calculation must therefore be fast. Also, a new mapping should be as close as possible to the previous mapping in order to minimize task migrations. Dynamic mapping methods exist but are based on iterative optimization algorithms. Many iterations are required to reach convergence. In the context of a distributed implementation, many communications are needed. We developed a new distributed dynamic mapping method which is not based on iterative optimization algorithms. Current results are encouraging. Load balancing execution time remains bounded for tested cluster sizes. Also, a decrease of ~20% of the global available computational power of a cluster leads to ~30% of migrated tasks during load rebalancing. A new mapping is therefore close to the previous one. [less ▲]

Detailed reference viewed: 130 (14 ULg)
Full Text
Peer Reviewed
See detailLBG-SQUARE - Fault Tolerant, Locality-Aware Co-allocation in P2P Grids
Dethier, Gérard ULg; Briquet, Cyril ULg; Marchot, Pierre ULg et al

in Huang, Zhiyi; Xu, Zhiwei; Rountree, Nathan (Eds.) et al Ninth International Conference On Parallel And Distributed Computing, Applications And Technologies : PDCAT 2008 (2008, December)

In this paper, the deployment and execution of Iterative Stencil applications on a P2P Grid middleware are investigated. So-called Iterative Stencil applications are composed of sets of heavily ... [more ▼]

In this paper, the deployment and execution of Iterative Stencil applications on a P2P Grid middleware are investigated. So-called Iterative Stencil applications are composed of sets of heavily-communicating, long-running Tasks. They thus require co-allocation of multiple reliable resources for extended periods of time. P2P Grids are totally decentralized and provide on-demand, transparent access to edge resources, e.g. Internet-connected, non-dedicated desktop computers. A P2P Grid has the potential to provide access to a large number of resources at the fraction of the cost of a dedicated cluster. However, edge resources are heterogeneous in performance and intrinsically unreliable: Task execution failures are common due to resource preemption or resource failure. Furthermore, P2P Grid schedulers usually target sets of independent computational Tasks, i.e. so-called Bags of Tasks applications. It is therefore not trivial to deploy and run an Iterative Stencil application on a P2P Grid. Checkpointing is a common fault-tolerance mechanism in High Performance Distributed Computing, often based on a centralized architecture. Locality-aware co-allocation in P2P Grids has been recently investigated. Checkpointing and locality-aware co-allocation yet have to be integrated in P2P Grids. We propose to provide co-allocation through an existing middleware-level Bag of Tasks scheduling mechanism. We also introduce a layer of fault-tolerance for the Iterative Stencils that relies on a scalable, application-level, P2P checkpointing mechanism. Finally, LBG-SQUARE is described. This software results from the combination of a specific Iterative Stencil application (a Computational Fluid Dynamics simulation software called LaBoGrid) with a P2P Grid middleware (Lightweight Bartering Grid). [less ▲]

Detailed reference viewed: 105 (21 ULg)
Full Text
Peer Reviewed
See detailReproducible Testing of Distributed Software with Middleware Virtualization and Simulation
Briquet, Cyril ULg; de Marneffe, Pierre-Arnoul ULg

in Ur, Shmuel (Ed.) Proceedings of the 6th Workshop on Parallel And Distributed systems: Testing, Analysis, and Debugging (2008, June 20)

P2P Grids are Grids organized into P2P networks where participant exchange computing time so as to complete computational tasks. Evaluating the performance of scheduling algorithms enables one to deploy ... [more ▼]

P2P Grids are Grids organized into P2P networks where participant exchange computing time so as to complete computational tasks. Evaluating the performance of scheduling algorithms enables one to deploy those that are efficient. Performance is often evaluated experimentally or through simulation because these algorithms (typically heuristics) are too complex to model analytically. Testing the implementation of P2P Grid middleware before it is deployed is also important: Reproducing configurations or conditions that lead to unexpected outcomes is thus valuable. A P2P Grid environment exhibits multiple sources of failure and is typically dynamic and uncontrollable. Reproducing even basic behavior of Grid nodes in a controllable and repeatable manner is thus exceedingly difficult. Such lack of control over the environment is a major challenge in the software engineering of P2P Grid middleware. Simulators have been proposed to evaluate the performance of scheduling algorithms, but are often limited in scope, reusability and accuracy, i.e. they rely on simplified models. We introduce a software engineering pattern - that we call code once, deploy twice - to both reduce the distance between simulated and implemented algorithms and reproduce, at will, Grid configurations and environments: A simulator implementation of a Grid architecture is built by virtualizing its middleware implementation. An immediate benefit is that most of the code can be reused between both implementations; only communications between Grid nodes, multithreading within Grid nodes and actual task execution are coded differently. As a derived benefit, most of the code of the middleware can be tested within the controlled environment of the simulator, before it is deployed as-is. Another benefit is high simulation accuracy. We describe the implementation of a P2P Grid following the code once, deploy twice pattern, that we believe is also relevant to other Grid types (certainly Volunteer Grids and Desktop Grids, and possibly Globus-based Grids). [less ▲]

Detailed reference viewed: 27 (2 ULg)
Full Text
Peer Reviewed
See detailArchitecture of a Grid-Enabled Lattice-Boltzmann Middleware
Dethier, Gérard ULg; Marchot, Pierre ULg; de Marneffe, Pierre-Arnoul ULg

Poster (2008, May)

Lattice-Boltzmann (LB) simulation methods constitute a family of computational fluid dynamics methods that can deal with complex multiphysics models and are easily parallelizable. They are based on ... [more ▼]

Lattice-Boltzmann (LB) simulation methods constitute a family of computational fluid dynamics methods that can deal with complex multiphysics models and are easily parallelizable. They are based on modified lattice-gas automata. The algorithm of LB simulations is quite simple. Space is discretized into a lattice. Each node of this lattice has a state. This state indicates the proportion of particules moving along fixed directions (these proportions are generally called “fields”). At each time step, the state of all lattice nodes is updated. Each node first receives fields coming from its neighbors and then “collides” them by applying a collision operator which generates the new state. Grid computing can be defined as “coordinated resource sharing and problem solving in dynamic, multi-institutional collaborations”. In practice, a Grid user (which can be a software component) submits a job composed of tasks to the Grid. The tasks are automatically run on available computational resources across organizational boundaries (i.e. clusters of multiple departments). LaBoGrid is an application combining the concepts of LB modelling and Grid computing. It is able to run LB simulations on an arbitrary number of computational resources from a Grid. It deals with operating system and hardware performance heterogeneity. The former because LaBoGrid is written in Java. The latter thanks to load-balancing. This is essential because all LaBoGrid tasks are inter- connected and depend on information from one another. A slow LaBoGrid task will slow down the overall process. LaBoGrid is based on asynchronous agents exchanging messages. The two main agents are the Controller agent (CA) and the distributed agent (DA). In a deployed LaBoGrid system, the CA exists in only one instance. It keeps track of the DAs and their topology. A task agent running some arbitrary code can be attached to the CA (CAT) and the DAs (DAT). In LaBoGrid, LB-specialized task agents are used (this system could be adapted to other problems). A configuration file parsed by the LB CAT gives the parameters of an LB simulation. The LB CAT configures automatically the LB DATs which handle the simulation code. Currently, LB simulations are done on 3D fluids with 19 fields per state. However, the code can be adapted very easily to other fluid dimensions and different state definitions, storage and computation precisions and collision types. [less ▲]

Detailed reference viewed: 103 (14 ULg)
Full Text
Peer Reviewed
See detailA Grid-enabled Lattice-Boltzmann-based modelling system
Dethier, Gérard ULg; Marchot, Pierre ULg; de Marneffe, Pierre-Arnoul ULg et al

in Wyrzykowski, Roman; Dongarra, Jack; Karczewski, Konrad (Eds.) et al Parallel Processing and Applied Mathematics (2007, September)

Lattice-Boltzmann (LB) methods are a well-known technique in the context of computational fluid dynamics. By nature, they can eas- ily be parallelized but their adaptation to the Grid environment is not ... [more ▼]

Lattice-Boltzmann (LB) methods are a well-known technique in the context of computational fluid dynamics. By nature, they can eas- ily be parallelized but their adaptation to the Grid environment is not trivial due to hardware heterogeneity (CPU, memory. . . ) in a Grid. A load balancing method to dynamically handle the differences in terms of CPU number and power among the machines of a Grid is presented. The CPU power is dynamically estimated using a benchmark. An estimation method of execution time is also given. [less ▲]

Detailed reference viewed: 111 (20 ULg)
Full Text
Peer Reviewed
See detailScheduling Data-Intensive Bags of Tasks in P2P Grids with BitTorrent-enabled Data Distribution
Briquet, Cyril ULg; Dalem, Xavier ULg; Jodogne, Sébastien ULg et al

in Fortino, Giancarlo; Mastroianni, Carlo; Pierre, Guillaume (Eds.) Proceedings of the Second Workshop on Use of P2P, GRID and Agents for the Development of Content Networks (2007, June 26)

Scheduling Data-Intensive Bags of Tasks in P2P Grids leads to transfers of large input data files, which cause delays in completion times. We propose to combine several existing technologies and patterns ... [more ▼]

Scheduling Data-Intensive Bags of Tasks in P2P Grids leads to transfers of large input data files, which cause delays in completion times. We propose to combine several existing technologies and patterns to perform efficient data-aware scheduling: (1) use of the BitTorrent P2P file sharing protocol to transfer data, (2) data caching on computational Resources, (3) use of a data-aware Resource selection scheduling algorithm similar to Storage Affinity, (4) a new Task selection scheduling algorithm (Temporal Tasks Grouping), based on the temporally grouped scheduling of Tasks sharing input data files. Data replication is also discussed. The proposed approach does not need an overlay network or Predictive Communications Ordering, making our operational implementation of a P2P Grid middleware easily deployable in unstructured P2P networks. Experiments show that performance gains are achieved by combining BitTorrent, caching, Storage Affinity and Temporal Tasks Grouping. This work can be summarized as combining P2P Grid computing and P2P data transfer technologies. [less ▲]

Detailed reference viewed: 56 (8 ULg)
Full Text
Peer Reviewed
See detailDescription of a Lightweight Bartering Grid Architecture
Briquet, Cyril ULg; de Marneffe, Pierre-Arnoul ULg

in Bubak, Marian; Turala, Michal; Wiatr, Kazimierz (Eds.) CGW'06 Proceedings (2006, October 18)

Automated resource exchange and negotiation between participants of a Virtual Organization, or Peers of a Peer-to-Peer Grid, is an important feature of Grid computing because it enables scalable ... [more ▼]

Automated resource exchange and negotiation between participants of a Virtual Organization, or Peers of a Peer-to-Peer Grid, is an important feature of Grid computing because it enables scalable cooperation between entities under separate administrative control. Automated negotiation and accounting of resource consumption have been studied, and market-based resource exchange methods have been proposed. However, there currently exist few simulators of resource exchange accounting or actual Grid middlewares supporting negotiation with automated resource usage accounting between separate entities. We propose a Lightweight Bartering Grid (LBG) architecture suitable to the development of Peer-to-Peer Grids based on bartering (i.e. automated and accounted resource exchange), where Peers model their environment. We present the LBG architecture as well as a simulator and a middleware under development that both instantiate it. [less ▲]

Detailed reference viewed: 41 (3 ULg)
Full Text
See detailWhat is the Grid ? Tentative Definitions Beyond Resource Coordination
Briquet, Cyril ULg; de Marneffe, Pierre-Arnoul ULg

Report (2006)

Ian Foster’s What is The Grid ? paper gives the generally accepted definition of Grid and Grid computing. While sound, it does not precisely define the involved concepts, which may lead to ... [more ▼]

Ian Foster’s What is The Grid ? paper gives the generally accepted definition of Grid and Grid computing. While sound, it does not precisely define the involved concepts, which may lead to misunderstandings. We propose a tentative set of definitions for Grid, Grid computing and related concepts such as Virtual Organization, Grid resource sharing architectures and policies. Several design parameters are identified, the impact of the resource environment is analysed and effective combinations of design parameters are reviewed. [less ▲]

Detailed reference viewed: 36 (1 ULg)
Peer Reviewed
See detailGrid Resource Negotiation: Survey with a Machine Learning Perspective
Briquet, Cyril ULg; de Marneffe, Pierre-Arnoul ULg

(2006, February)

Grid computing can be defined as coordinated resource sharing and problem solving in dynamic, multi-institutional collaborations. As more Grids are deployed worldwide, the number of multi-institutional ... [more ▼]

Grid computing can be defined as coordinated resource sharing and problem solving in dynamic, multi-institutional collaborations. As more Grids are deployed worldwide, the number of multi-institutional collaborations is rapidly growing. However, for Grid computing to realize its full potential, it is expected that Grid participants are able to use one another resources. Resource negotiation (i.e. exchange or trading of resources between Grids) enables Grid participants to face an unstable request environment. The aim of this position paper is to present a survey of the current state and challenges of resource negotiation research, with a Machine Learning perspective. We support the view that negotiation and learning are intrinsically linked. In particular, we show the expected benefits of integrating Machine Learning techniques with resource negotiation. [less ▲]

Detailed reference viewed: 37 (2 ULg)
Full Text
Peer Reviewed
See detailLearning Reliability Models of Grid Resource Supplying
Briquet, Cyril ULg; de Marneffe, Pierre-Arnoul ULg

in Bubak, Marian; Turala, Michal; Wiatr, Kazimierz (Eds.) CGW'05 Proceedings (2005, November 22)

Resource exchange between Grid participants is at the core of Grid computing. Distributed bartering is a distributed and moneyless method of resource exchange. Recent work related to distributed bartering ... [more ▼]

Resource exchange between Grid participants is at the core of Grid computing. Distributed bartering is a distributed and moneyless method of resource exchange. Recent work related to distributed bartering has mainly dealt with resource supplying. However, Grid participants still face an unstable resource environment due to the partial and intermittent nature of the exchanged resources. The problem considered in this paper is the unreliability of resource supplying. Though it cannot be totally avoided, a proactive stance may lower its impact in the long run. We propose to explore the reduction of performance variability by improving resource consumption. The goal is to enable Grid participants to identify and avoid unreliable resource suppliers by learning reliability models of resource supplying. A Machine Learning problem is defined and the generated models are applied to select more reliable resources in the hope of improving resource consumption. [less ▲]

Detailed reference viewed: 30 (6 ULg)