Computational Steering in RealityGrid
J M Brooke*, P V Coveney†, J Harting†, S Jha†,
S M Pickles*, R L Pinning* and A R Porter*
* Manchester Computing, University of Manchester
† Centre for Computational Science, University College London
http://www.realitygrid.org
http://www.realitygrid.org
Problems associated with demanding high performance computational science are not confined to merely finding resources with larger numbers
of processors or memory. Simulations that require greater computational resources also require increasingly sophisticated and complex
tools for the analysis and management of the output of the simulations. For a range of scientific applications, controlling the evolution of a
computation based upon the realtime analysis and visualisation of the status of a simulation alleviates many of the limitations of a simple
simulate-then-analyse approach. Computational steering is the functionality that enables the user to influence the otherwise sequential
simulation and analysis phases by merging and interspacing them. A central
theme
of
RealityGrid is the facilitation of distributed and
interactive exploration of physical models and systems through computational steering of parallel simulation codes and simultaneous on-line,
high-end visualisation. We provide design and implementation details of the RealityGrid steering library and toolkit. The capabilities of the library
are
outlined and
the service-orientated architecture of the latest implementation based on the Open Grid Services Infrastructure is
presented. Using the simulation of complex fluids by Lattice Boltzmann methods as an example, we show the advantages that a powerful,
flexible computational steering framework provides the physical scientist, i.e, how it enables more effective utilization of computational resource
and enhances a scientist's productivity.
Implementation
Computational Steering
Large-scale simulations (and experiments) can generate in days data that
takes months to understand. Computational steering aims to short circuit
post facto analysis by enabling the scientist to navigate their
simulation/experiment through interesting regions of parameter space. The
provision of simultaneous, on-line visualisation develops and engages the
scientist's intuition.
Allowing the scientist to interact with their
simulation/experiment thus helps him/her avoid wasting valuable
computation/experiment time exploring barren regions or even doing the
wrong calculation. These and other benefits of computational steering are
explored further in [1].
Steering GS
Steering library
publish
client
connect
Steering
Steering
library
find
Registry
• Suitable for use in parallel programs – no restriction on programming
paradigm or technology (e.g. MPI , OpenMP etc.). Bindings available for
common scientific languages – F90, C and C++;
• Combination of API and ‘reverse communication’ approach gives application
scientist considerable flexibility in choosing how much steering functionality
they wish to implement;
• Single library API supports both local (file-based) and remote (via grid
service using SOAP over HTTP) steering. Steering grid service implemented
in Perl and hosted by the OGSI::Lite package by Mark Mc Keown [2];
Simulation
bind
Client
• Steering functionality made available to application via subroutine library
data
transfer
Functionality
• Qt-based steering client for Linux and IRIX built on the steering library;
• Support for:
•Dynamic attach and detach from running simulation;
•Parameter monitoring (and plotting);
publish
Steering library
bind
Steering GS
•Parameter steering (with bounds);
•Stop and Pause commands;
Visualisation
•Control of data-set emission (via globus_io);
Figure 1: The RealityGrid steering architecture.
•Control of checkpointing and restart;
• vtk-based visualisation component using globus_io for data transfer.
Architecture
• RealityGrid applications consist of one or more software components (e.g.
molecular dynamics simulation plus visualisation);
• Public computational-steering interface for steerable components provided
by a grid service (Figure 1);
• Steerable components can be discovered and steered through standard
grid-service technology; Grid-service framework allows automatic
construction of inter-component connections (e.g. socket for large data
transfers);
• Components can be added to or removed from the application dynamically
(e.g. introduce a data filter or a different visualisation).
Figure 2: The Qt-based steering client.
Lattice Boltzmann methods
Complex Fluids
Vortex Knot Evolution
• The lattice Boltzmann method is a mesoscale
method for simulating complex fluids. This is
something traditional CFD cannot do.
• Can simulate:
• flow in porous media: industrial applications e.g.
hydrocarbon recovery process (A). Using a 10243
simulation we can now model ~1cm3 of rock
• non-equilibrium process of self-assembly of
amphiphilic fluids into equilibrium liquid-crystalline
cubic mesophases.(e.g. gyroid phase B).
• sheared equilibrium mesophases (C).
• Vorticity is the curl of the hydrodynamic
velocity, and is strongest at the core of a
swirling region of fluid. At high Reynolds
number, regions of high vorticity tend to
form filamentary structures
• We study the dynamical behaviour of
vortex knots and links for single phase
fluids
How Computational Steering helps:
• Steering has proved useful for detecting and studying topological
changes in vortex cores
• Once a change is detected we can return to the last checkpoint and improve
either the spatial or temporal resolution of the simulation
• The figure below shows how steering through parameter space
allows a computational scientist to uncover different binary phases
Cubic micellar phase,
high surfactant density
gradient.
Initial condition:
Random water/
surfactant mixture.
Figure 4:.Evolution of a (2,3) torus knot
using Lattice Boltzmann on a 1003 grid
B
A
Self-organization
starts.
Rewind and
restart from
checkpoint.
Cubic micellar phase,
low surfactant density
gradient.
Lamellar phase:
surfactant bilayers
between water layers.
(Work on the Vortex Knot evolution is by Prof.
Bruce Boghosian’s group at Tufts University)
C
Figure 3: Different physical systems studied.
• A Grid infrastructure that permits the coordination of heterogeneous and distributed computing resources
provides a natural testbed for demonstrating the effectiveness of computational steering
References
[1] J Chin, J Harting, S Jha, P V Coveney, A R Porter and S M Pickles, Steering in computational science: mesoscale modelling and simulation,
Contemporary Physics, 44 (5), pp 417-434
[2] M Mc Keown, OGSI::Lite; a Perl OGSI-compliant hosting environment, http://www.sve.man.ac.uk/Research/AtoZ/ILCT.