Utilizing GPU worth it?

3
votes

I want to compute the trajectories of particles subject to certain potentials, a typical N-body problem. I've been researching methods for utilizing a GPU (CUDA for example), and they seem to benefit simulations with large N (20000). This makes sense since the most expensive calculation is usually finding the force.

However, my system will have "low" N (less than 20), many different potentials/factors, and many time steps. Is it worth it to port this system to a GPU?

Based on the Fast N-Body Simulation with CUDA article, it seems that it is efficient to have different kernels for different calculations (such as acceleration and force). For systems with low N, it seems that the cost of copying to/from the device is actually significant, since for each time step one would have to copy and retrieve data from the device for EACH kernel.

Any thoughts would be greatly appreciated.

2
cudagpusimulation
The GFOR loop is exactly targeted at these kinds of problems (small data sizes but lots of iterations). Check it out in ArrayFire (I'm one of the guys working on it): accelereyes.com/arrayfire/c/page_gfor.htm - arrayfire
Note that with the upcoming C++17 you might be able to experiment with both options using the same code and different attributes in parallell_for and such. - einpoklum

2 Answers

3
votes

If you have less than 20 entities that need to be simulated in parallel, I would just use parallel processing on an ordinary multi-core CPU and not bother about using GPU.

Using a multi-core CPU would be much easier to program and avoid the steps of translating all your operations into GPU operations.

Also, as you already suggested, the performance gain using GPU will be small (or even negative) with this small number of processes.

1
votes

There is no need to copy results from the device to host and back between time steps. Just run your entire simulation on the GPU and copy results back only after several time steps have been calculated.

For how many different potentials do you need to run simulations? Enough to just use the structure from the N-body example and still load the whole GPU?

If not, and assuming the potential calculation is expensive, I'd think it would be best to use one thread for each pair of particles in order to make the problem sufficiently parallel. If you use one block per potential setting, you can then write out the forces to shared memory, __syncthreads(), and use a subset of the block's threads (one per particle) to sum the forces. __syncthreads() again, and continue for the next time step.

If the potential calculation is not expensive, it might be worth exploring first where the main cost of your simulation is.