Determining Computing Requirements

Question

I am looking at building/buying myself a workstation for scientific computing. I will be doing molecular dynamics simulations that are memory intensive (data on a large number of particles and a million time steps or more) and require multiple instances of the same code running (to generate an ensemble). I am new to computing but my guess is I will be using C++ and learn to utilize the best memory handling practices. In terms of ensemble averaging, it appears to me I could either just run the code N times or maybe run N instances of the codes in simultaneously on N processors. At this point I don't have access to HPC resources and I am only trying to get a simple desktop (maybe 2 or 4 cores) but I want to learn to make this code parallel.

At this point I know very little about the code itself to make a more specific assessment of my needs. However, my question is what might be the very essential features I should keep in mind while buying a workstation. For example, things to keep in mind if eventually I want to transition to HPC, things to keep in mind if some amount of parallel processing needs to be done (or just having 2 or more cores in enough) etc.

Answer 1

There are quite a few unknowns in your question, so I'll try to make this answer as broad as possible.

By the sound of it, you're considering writing your own MD code. Writing an MD code is easy, but writing a good, i.e. efficient and correct, MD code is very, very difficult, not to mention time-consuming. Unless you're studying some special case of physics or geometry which can not be handled by existing MD codes/libraries, or you are a Computer Scientist looking at some new algorithmic challenges, I would advise you first try to use existing software packages.

If your MD requirements are relatively standard, i.e. no special potential functions or interactions, then I would strongly recommend using one of the most popular Open-Source software packages such as NAMD or GROMACS.

If you have any exotic requirements, you could look at MD libraries such as MMTK (in Python), OpenMM (in C), or mdcore (in C, note tat this is my own code). These allow you to do most of the nuts and bolts bits of MD simulations, but also let you access and manipulate the particle data directly.

With the exception of MMTK, all of these codes/libraries can use GPUs. If you're looking to run long simulations efficiently, then GPUs are definitely the way to go, especially in terms of their bang/buck ratio. GPUs can also be used to run relatively large simulations as most models currently have several gigabytes of memory on board. We regularly use NAMD's STMV setup as a benchmark, which consists of more than one million particles. Also, if you have a machine with multiple GPUs, you can run several simulations in parallel, one on each GPU.

In summary, I would not recommend writing your own code unless that is the ultimate goal of your research. Stick to existing packages and/or libraries, depending on your needs, and keep in mind that GPUs are currently the most efficient workhorses for MD simulations.

Answer 2

Here are three architectures you could evaluate against your needs. Considering them may help you formulate your needs more concretely. If you, as Pedro suggest, base your work on an existing software package (and I think you should) compatibility with that package will help narrow down the alternatives.

1. You could consider something from the Intel Xeon Phi family, which you can slot into a PC cabinet and which sets you back about $2700.
2. Go with a GPU-based program
3. Run things initially on virtual machines in the cloud. Easy to scale up and get a feel for just how much parallellism you actually need. (won't go down well with licensing of some software packages)

Answer 3

In the simplest case, you can simulate an HPC environment using a computer with 2 or more cores. You can run both OpenMP and/or MPI in such an environment.

Typically, if you're doing large calculations on an HPC, you might use more than one compute node. This means there are two 'computers', communicating across a network. This imposes some constraints compared to a single multithreaded compute node:

• OpenMP is no longer sufficient for parallelization, at least on its own. MPI becomes the de facto standard
• the network speed becomes a huge bottleneck for computation

Now this doesn't mean that you can't run HPC code if you only have a single 2-core PC. You can. And the easiest way is to use MPI for parallelizing your code, rather than OpenMP, or pthreads and so on. However, if you can get access to two or more multicore PCs, with a fast network between them (at least Gigabit), then this will give you a better feel for what is possible.

So much for multicore processing using MPI. Another thing to think about is GPGPU. Clusters nowadays often make GPUs available to you, which you can use for linear algebra, using libraries such as gnumpy in python, or similar. If you want to be able to experiment with GPGPU, you will probably want to either:

• get a computer with a GPU that can run CUDA code, ie an nVidia GPU
• get a computer that can run OpenCL. In fact, Intel processors since last year (Ivy bridge onwards) contain an OpenCL-compliant GPU. AMD processors also contain OpenCL-compliant GPUs.

So, in summary:

• the simplest system to experiment with MPI would be a dual-core CPU
• for more realistic experimentation, you want two networked multi-core PCs
• you might also consider obtaining either a CUDA or OpenCL compliant GPU, or making sure that your CPU contains an OpenCL-compliant GPU.