Group Project: instant-access parallel fluid simulation and visualisation

Supervisor: Paul Kelly

 

The goal of this project is to connect a computationally-intensive parallel simulation program to a visualisation front-end in an interesting way. Suppose we are simulating 3-D fluid flow in a 512x512x512 region. At each timestep, we generate at least one 512^3=128M-element array, occupying 1GB. We want the use to be able to browse this data, extracting features (eg vortices), and visualising them using standard tools (such as contouring/isosurfaces). We want to be able to watch these features as they evolve in time.   One way to think about this is that we are taking a batch fluid flow simulation and turning it into an on-line server that delivers selected visualisations of its output.  The challenge is to structure the system by formulating the fluid flow simulator and the visualisation code as flexible parallel components.  These components should carry information about how best they should be executed depending on the context of use.  The objective is to build a testbed for research work on (1) how to align parallel components to minimise data movement, and (2) how to cache the output from components to improve interactive responsiveness.

 

 

The job:
 

• Getting started:

• Get the example parallel computational fluid dynamics (CFD) application to work on your machine. I recommend you use the NaSt3DGP package.
• Experiment with it. Run it in parallel using MPI using idle CSG linux machines (I have a little program called mpidle/mpidled (see ~phjk/bin) that tells you which machines appear to be idle).
• Install VTK, the visualisation toolkit. 

• Implementation - subproject 1

• Build a simple visualisation GUI using C++ and VTK (and Qt), and use it to inspect the program's output. Allow the user to extract features, zoom in on them, and watch how they evolve in time.
• Evaluate the real-time responsiveness, and scalability - how large a problem can you handle?  Use profiling tools, add instrumentation, plot graphs
• Do some tuning and caching to improve the real-time responsiveness (eg cache some recomputed data to avoid recomputing)

• Implementation - subproject 2

• Build a completely separate GUI (or a GUI component?) to control execution of the NaSt3DGP program.
• Use mpidle/mpidled to identify available machines for parallel execution, and get the GUI to select the appropriate set of machines to run each time
• You will probably find that performance is limited by the time taken to write out the data file at each timestep.  Modify NaSt3DGP to do this in parallel.  Perhaps parallelise file reading too.

• Implementation - subproject 3

• NaSt3CGP's input file format is a description of the 3-D world in which the fluid is flowing, in a format similar to VRML.  We want the user to be able to manipulate the 3-D world visually, then run the program and visualise how the fluid flows.  Build a GUI component that allows you to do this.
• Use it to develop some interesting examples, and use the output from these to exercise and guide the visualisation subproject above

• Synthesis

• Combine the three GUI components into a single GUI that allows you to edit a 3-D scene, use parallelism to calculate the flow over time, and visualise the results
• Produce a beautiful report with lots of beautiful pictures
• Produce a Linux rpm so you can distribute the software to friends etc
• Investigate the performance of the parallel execution, in particular look at how best to cache intermediate results, how to recruit idle machines and re-assign work when they become busy, whether other jobs seriously interfere with performance, and whether it's important to reuse a machine which you recently used in order to save reloading code and data.

I want to be able to

• use the GUI to mark and contour features of interest
• watch an animation of how the features evolve with time
• zoom in on a region of the fluid flow, then redo the animation
• change the shape/position of objects and see how the flow changes

Minimum result:

• A GUI-driven tool for visualising output from the CFD program

Major objectives:

• A really cute interactive tool for investigating and understanding fluid flow
• Study of parallel component architecture, systematically minimising data movement, systematically using caching to avoid recalculation.
• Quantitative evaluation of resulting responsiveness

What you need to know:

This project is fairly challenging and there is enormous scope. You need to be unfazed by complexity. You do not need to understand the maths behind CFD, though it helps if, like me, you like the pictures! Both vtk and NaSt3DGP are written in C++, though a good knowledge of C should be enough for most purposes. Some background in visualisation and graphics will come in handy. You should be able to pick up new tools very quickly.  This is more than simply an engineering project; I'm interested in learning how to connect parallel software components, how to use resources whose availability varies in time, etc.  This is part of my long-term research plan to investigate cross-component optimisation of scientific applications running on a computational "power grid".  See my home page for more details.

What you need: access to the VTK book, vtk, mpich, NaSt3DGP.  No special project machine should be needed, but you will need several PCs at the same time for some of the development and testing.