Claude Mazel

Simulation of the mollusc Ascoglossa Elysia subornata population dynamics: application to the potential biocontrol of Caulerpa taxifolia growth in the Mediterranean Sea

A multi-modelling simulation was performed to assess the potentialities of a biocontrol of the alga Caulerpa taxifolia (Valhl) C. Agardh by the Ascoglossa Elysia subornata (Verrill, 1901) in the Mediterranean Sea. With this aim in view, the biological and ecological parameters considered as key factors were identified in order to present a state of the art on biological and ecological parameters related to the behaviour of E. subornata toward C. taxifolia and toward the Mediterranean conditions. To this end, growth, survival, reproduction, feeding on C. taxifolia and foraging of E. subornata are studied. Simulations, taking into account spatial effects, give encouraging results and show that additional experiments in large mesocosm may be engaged to improve the actual knowledge of Elysia behaviour, the impact on C. taxifolia, the trophic relationships, etc. The results of simulations demonstrate that the greatest impacts on Caulerpa are obtained using either some adults or mixing adults and juvenile slugs. In any case, better results are obtained by a scattering of slugs on isolated spots rather than on clusters (with constant surfaces). Lastly, the choice of a suitable date for scattering increases the weak consumption of Caulerpa resulting from the scattering of juvenile slugs.

Distribution of Random Streams for Simulation Practitioners

There is an increasing interest in the distribution of parallel random number streams in the high‐performance computing community particularly, with the manycore shift. Even if we have at our disposal statistically sound random number generators according to the latest and thorough testing libraries, their parallelization can still be a delicate problem. Indeed, a set of recent publications shows it still has to be mastered by the scientific community. With the arrival of multi‐core and manycore processor architectures on the scientist desktop, modelers who are non‐specialists in parallelizing stochastic simulations need help and advice in distributing rigorously their experimental plans and replications according to the state of the art in pseudo‐random numbers parallelization techniques. In this paper, we discuss the different partitioning techniques currently in use to provide independent streams with their corresponding software. In addition to the classical approaches in use to parallelize stochastic simulations on regular processors, this paper also presents recent advances in pseudo‐random number generation for general‐purpose graphical processing units. The state of the art given in this paper is written for simulation practitioners. Copyright

Pseudo-Random Number Generation on GP-GPU

Random number generation is a key element of stochastic simulations. It has been widely studied for sequential applications purposes, enabling us to reliably use pseudo-random numbers in this case. Unfortunately, we cannot be so enthusiastic when dealing with parallel stochastic simulations. Many applications still neglect random stream parallelization, leading to potentially biased results. Particular parallel execution platforms, such as Graphics Processing Units (GPUs), add their constraints to those of Pseudo-Random Number Generators (PRNGs) used in parallel. It results in a situation where potential biases can be combined to performance drops when parallelization of random streams has not been carried out rigorously. Here, we propose criteria guiding the design of good GPU-enabled PRNGs. We enhance our comments with a study of the techniques aiming to correctly parallelize random streams, in the context of GPU-enabled stochastic simulations.

Pseudo-random streams for distributed and parallel stochastic simulations on GP-GPU

Random number generation is a key element of stochastic simulations. It has been widely studied for sequential applications purposes, enabling us to reliably use pseudo-random numbers in this case. Unfortunately, we cannot be so enthusiastic when dealing with parallel stochastic simulations. Many applications still neglect random stream parallelization, leading to potentially biased results. In particular parallel execution platforms, such as Graphics Processing Units (GPUs), add their constraints to those of Pseudo-Random Number Generators (PRNGs) used in parallel. This results in a situation where potential biases can be combined with performance drops when parallelization of random streams has not been carried out rigorously. Here, we propose criteria guiding the design of good GPU-enabled PRNGs. We enhance our comments with a study of the techniques aiming to parallelize random streams correctly, in the context of GPU-enabled stochastic simulations.

ShoveRand: A model-driven framework to easily generate random numbers on GP-GPU

Stochastic simulations are often sensitive to the randomness source that characterizes the statistical quality of their results. Consequently, we need highly reliable Random Number Generators (RNGs) to feed such applications. Recent developments try to shrink the computation time by using more and more General Purpose Graphics Processing Units (GP-GPUs) to speed-up stochastic simulations. Such devices bring new paral-lelization possibilities, but they also introduce new programming difficulties. Since RNGs are at the base of any stochastic simulation, they also need to be ported to GP-GPU. There is still a lack of well-designed implementations of quality-proven RNGs on GP-GPU platforms. In this paper, we introduce ShoveRand, a framework defining common rules to generate random numbers uniformly on GP-GPU. Our framework is designed to cope with any GPU-enabled development platform and to expose a straightforward interface to users. We also provide an existing RNG implementation with this framework to demonstrate its efficiency in both development and ease of use.

Proper parallel Monte Carlo for computed tomography of volcanoes

Most Monte Carlo simulations can be parallelized, or at least easily distributed. However, the parallelization of such programs is not mainstream. In this paper, we propose good practices to distribute a Monte Carlo simulation for computed tomography. We apply this to large edifices (such as volcanoes or pyramids) and give a particular focus on performances. The work included first the optimization of an existing sequential prototype and second the use of reliable parallel random streams. The optimized parallel version runs on a Symmetric Multi-Processor (SMP) and shows a fine and scalable speedup. The cumulated optimizations (sequential and parallel) enabled a speedup of 400X on a 32 cores SMP.

An individual-based, stochastic and spatial model to simulate the ramification of grass tillers and their distribution in swards

Abstract Understanding the vegetation dynamics of a grass sward at fine-scale requires breaking the interplay between density-dependent processes and environmental variability. Simulation of one of these interacting processes may be a powerful tool. SISTAL is a spatially explicit, object-oriented model of the spatial distribution and spatio-temporal dynamics of individual grass tillers in cut swards. It focuses both on the spatial movement of existing tillers and on the birth and death of tillers. The time management is based on discrete events, and the system dynamics is computed with thermal time. The space management uses both a spatial grid and real coordinates. The paper exposes implementation choices that have been carefully selected: inputs and outputs; edge effects; implementation of the memory management and the handling of pseudo-parallelism. The simulation diary is described since it was found a very useful tool for verification. Essential results and comparisons with real observations allowing the validation of the model are presented.

TaskLocalRandom: a statistically sound substitute to pseudorandom number generation in parallel java tasks frameworks

Several software efforts have been produced over the past few years in various programming languages to help developers handle pseudorandom streams partitioning. Parallel and distributed stochastic simulations can obviously benefit from this kind of high‒level tools. The latest release of the Java Development Kit (JDK 7) tries to tackle this problem by providing facilities to partition a pseudorandom stream across various threads thanks to the new class ThreadLocalRandom. Meanwhile, Java 7 offers a framework to split a problem in a divide and conquer way through the new class called ForkJoinPool. As any other Java thread pool, ForkJoin exploits threads as workers and manipulates the tasks that will be run on the workers. In ThreadLocalRandom, pseudorandom number generation is handled at a thread level. As a consequence, a scientific application taking advantage of a Java thread pool to parallelize its computation may suffer from a bad pseudorandom stream partitioning due to the behavior of ThreadLocalRandom. The present work introduces TaskLocalRandom, a task‒level alternative to ThreadLocalRandom that solves this partitioning problem and assigns an independent pseudorandom stream to each task run in the thread pool. TaskLocalRandom is compatible with existing Java thread pools such as Executors or ForkJoin. Copyright

ThreadLocalMRG32k3a: A statistically sound substitute to pseudorandom number generation in parallel Java applications

Parallel And Distributed Simulations (PADS) become more and more spread since scientists always want more accurate results in the shortest time. PADS are often sensitive to several parameters, and when they own a stochastic component, one has to ensure he knows how to correctly deal with randomness in a parallel application. This point can appear to be very tricky for non-experts, who might be tempted to move this part of the simulation aside. Several software efforts have been produced in various programming languages to help developers handle pseudorandom streams partitioning in PADS. However, these tools remain third-party libraries that need to be integrated in already existing applications, and that might be hardly swappable. The latest release of the Java Development Kit (JDK 7) tries to tackle this problem with a new class called ThreadLocalRandom. The latter is in charge of safe pseudorandom number generation across Java threads. The present work studies the pros and cons of this approach, and introduces ThreadLocalMRG32k3a, an alternative to ThreadLocalRandom that shows better results in terms of generation speed and statistical quality. ThreadLocalMRG32k3a respects the same Application Programming Interface (API) as ThreadLocalRandom, thus enabling clients to use it in place of its JDK counterpart at no cost.

Performance analysis with a memory-bound Monte Carlo simulation on Xeon Phi

Physics simulations are known to be great resources exhausters (CPU, memory). Hardware acceleration can help reduce the need for CPU time and increase the available memory bandwidth. In this paper, we present the performance gain when running a memory-bound muon Monte Carlo simulation on an Intel Xeon Phi and an Intel Xeon CPU. We show how to increase performance on the Xeon Phi without modifying the Physics software frameworks we are using for our application. We investigate distributed simulations on multicore and manycore systems and also the impact of hyper-threading on performance. We extend this to a hybrid computing model, balancing the computing burden between both the manycore and multicore processors of a computing node. Finally, we improved memory usage on the Xeon Phi by sharing Kernel Memory pages using KSM, and we show that, using this approach, we can run 16% more simulation instances.