References of "Dethier, Gérard"
     in
Bookmark and Share    
Full Text
See detailDesign and Implementation of a Distributed Lattice Boltzmann-based Fluid Flow Simulation Tool
Dethier, Gérard ULg

Doctoral thesis (2011)

Lattice Boltzmann-based (LB) simulations are well suited to the simulation of fluid flows in complex structures encountered in chemical engineering like porous media or structured packing used in ... [more ▼]

Lattice Boltzmann-based (LB) simulations are well suited to the simulation of fluid flows in complex structures encountered in chemical engineering like porous media or structured packing used in distillation and reactive distillation columns. These simulations require large amounts of memory (around 10 gigabytes) and would require very long execution times (around 2 years) if executed on a single powerful desktop computer. The execution of LB simulations in a distributed way (for example, using cluster computing) can decrease the execution time and reduces the memory requirements for each computer. Dynamic Heterogeneous Clusters (DHC) is a class of clusters involving computers inter-connected by a local area network; these computers are potentially unreliable and do not share the same architecture, operating system, computational power, etc. However, DHCs are easy to setup and extend, and are made of affordable computers. The design and development of a software system which organizes large scale DHCs in an efficient, scalable and robust way for implementing very large scale LB simulations is challenging. In order to avoid that some computers are overloaded and slow down the overall execution, the heterogeneity of computational power should be taken into account. In addition, the failure of one or several computers during the execution of a simulation should not prevent its completion. In the context of this thesis, a simulation tool called LaBoGrid was designed. It uses existing static load balancing tools and implements an original dynamic load balancing method in order to distribute the simulation in a way that minimizes its execution time. In addition, a distributed and scalable fault-tolerance mechanism based on the regular saving of simulation’s state is proposed. Finally, LaBoGrid is based on a distributed master-slave model that is robust and potentially scalable. [less ▲]

Detailed reference viewed: 225 (52 ULg)
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: 136 (8 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 detailA Distributed Lattice Boltzmann-based Flow Simulator
Dethier, Gérard ULg

Conference (2009, January 22)

The use of Lattice Boltzmann (LB) methods is interesting to describe flows through complex geometries encountered in Chemical Engineering (porous media, packed beds, multi phase flows). However, flow ... [more ▼]

The use of Lattice Boltzmann (LB) methods is interesting to describe flows through complex geometries encountered in Chemical Engineering (porous media, packed beds, multi phase flows). However, flow simulations based on LB methods can require big amounts of memory. It is not always possible to run a simulation on a single machine. Distributed computing is a solution to this problem and also accelerates the execution of the flow simulation. In the context of dynamic heterogeneous clusters, the available machines can have different computational powers. The computational power of each machine can vary during a flow simulation (because of background load). Also, the number of available machines can change. These characteristics impose the use of special technics. Dynamic Load Balancing allows the optimal use of available machines. A fault occurs when one or several machines interrupt the execution of the distributed software component they were executing. Checkpointing makes the system fault tolerant. In order to obtain a scalable software and to suppress single points of failure, a special effort is made to decentralize as much as possible the software components of the simulator. Currently, fluid flows of 400³ points (more than 9 GBytes of data) are simulated using an heterogeneous cluster of 54 machines. [less ▲]

Detailed reference viewed: 127 (28 ULg)
Full Text
Peer Reviewed
See detailLattice Boltzmann 3D flow simulations on a metallic foam
Beugre, Djomice Antoine ULg; Calvo, Sébastien ULg; Dethier, Gérard ULg et al

in Journal of Computational & Applied Mathematics (2009)

Detailed reference viewed: 213 (27 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: 104 (21 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: 102 (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: 109 (20 ULg)