Barnes-Hut | A simple implementation of the Barnes-Hut quadtree algorithm | Learning library

I'm implementing a distributed version of the Barnes-Hut n-body simulation in Chapel. I've already implemented the sequential and shared memory versions which are available on my GitHub.

I'm following the algorithm outlined here (Chapter 7):

1. Perform orthogonal recursive bisection and distribute bodies so that each process has equal amount of work
2. Construct locally essential tree on each process
3. Compute forces and advance bodies

I have a pretty good idea on how to implement the algorithm in C/MPI using MPI_Allreduce for bisection and simple message passing for communication between processes (for body transfer). And also MPI_Comm_split is a very handy function that allows me to split the processes at each step of ORB.

I'm having some trouble performing ORB using parallel/distributed constructs that Chapel provides. I would need some way to sum (reduce) work across processes (locales in Chapel), splitting processes into groups and process-to-process communication to transfer bodies.

I would be grateful for any advice on how to implement this in Chapel. If another approach would be better for Chapel that would also be great.

I was under the assumption that if I write my code in Cython using the nogil directive, that would indeed bypass the gil and I could use a ThreadPoolExecutor to use multiple cores. Or, more likely, I messed up something in the implementation, but I can't seem to figure out what.

I've written a simple n-body simulation using the Barnes-Hut algorithm, and would like to do the lookup in parallel:

I have implemented an N-body simulation using the Barnes-Hut optimisation in Python which runs at a not-unacceptable speed for N=10,000 bodies, but it's still too slow to watch real time.

A new frame is generated each time-step, and to display the frame we must first calculate the new positions of the bodies, and then draw them all. For N=10,000, it takes about 5 seconds to generate one frame (this is waaay too high as Barnes-Hut should be giving better results). The display is done through the pygame module.

I would thus like to record my simulation and replay it once after it's done at a higher speed.

How can I accomplish this without slowing down the program or exceeding memory limitations?

One potential solution is simply to save the pygame screen each timestep, but this is apparently very slow.

I thought also about storing the list of positions of the bodies generated each time step, and then redrawing all the frames once the situation finishes. Drawing a frame still takes some time, but not as much time as it takes to calculate the new positions.