Parallelizing Maze Generation and Particle Filtering Milestone

Milestone update from Utkarsh and Justin!

Midpoint Summary

For our graph generation, we have managed to create a sequential version of the maze generator, based on a randomized version of the Kruskal's algorithm. However, it is far too slow, and doesn't always generate a path inside and outside of the maze. Moreover, we have yet to see if this is a good algorithm to optimize using the OpenMP, and hence, may change the algorithm. To avoid non-blocking the particle generator, we have created a few static grids for development and testing.

We were able to generate particles sequentially and create a grid structure to update the maze with ease. We had a lot of trouble renderering to a console using openGL on the gates machines (for MAC users it's a struggle) and so we have fallen behind schedule. The particle filtering sequential version is almost implemented (the math behind is a little difficult and we need to efficiently find line intersections). Anyway, a lot of work was put into structuring the files that made sense as we went through refractoring our code. We are now able to add walls and detect particle collisions. In the future, we plan to implement a robot in the maze that can determine it's location in the grid and figure it's way out. Instead of openMPI, we will most likely use CUDA because the data parallel model is more apt for a particle.


Goals/Deliverables

As mentioned in the summary, we are a bit behind schedule (due to our busy work schedules with other classes scheduling midterms/homework right before Thanksgiving Break). At the moment, we are on track to complete the sequential version of maze generation and particle filtering by the end of the week. The parallel version for particle filtering (CUDA) will be implemented the week after, with bugs sorted out. For the graph, we will experiment with other algorithms, and choose one that has the highest likelihood of being a good parallel target. By the project deadline, we plan to have a demo of parallel maze generation and particle filtering. Most likely there will plots of speedup on different cores.


Roadblocks (oh the struggles!)

We hit some hiccups implementing parallel maze generation and particle filtering


Rendering the console in openGL

  • We had a rough time creating a window that could be rendered on

  • The math behind particle filtering is complex

  • took longer than expected to correctly implement. Here are the steps of particle filtering
  • 1) transition particles
  • 2) fire rays to intersect walls (this may have cool parallel implentations unbeknownst)
  • 3) reweight particles (particles with similar observations should be given higher probability that the robot exists there)
  • 4) resample particles based on their weight
  • Steps 2-4 are still buggy.

    Makefile is hard to understand

  • Understanding how to write a makefile was painful because sometimes the files wouldn't link correctly

  • Environment Problems due to Mac/Linux mismatch (ongoing)

  • We struggled immensenly with trying to setup the X11 forwarding with on one of our machines (Utkarsh uses Mac, Justin uses Linux). Specifically, the problems were:
  • 1. We were using CUDA libraries on the GHC machines, and we thought removing them temporarily might fix the forwarding issue.
  • 2. However, OpenGL started complaining about 'unsufficient resources', which again we backtraced to X11 forwarding.
  • 3. Utkarsh tried using the development environment locally, but again CUDA libraries could not installed on Mac successfully.
  • 4. Finally, we tried to work on a VM on Mac, however the VirtualBox failed, and had to be re-installed and re-configured.
  • 5. We're still trying to fix the VM, which isn't working correctly inside the VirtualBox.
  • 6. As such, we've had to do development on the Mac, and test on one single machine (Justin's linux). We plan to either fix up the environment issues by this week, or Utkarsh will work from GHC clusters.


  • (Updated) Schedule

    11/26

    Sequential Version of Graph/Particle Filtering fully implemented

    (Utkarsh/Justin)
  • Bugs may still exist, but implemented thoroughly to move on
  • 12/3

    CUDA version of Particle Filtering and openMP for maze generation

    (Utkarsh/Justin)
  • Debugging bugs, if any.
  • 12/10

    Performance tunning and Report Writing

    (Utkarsh/Justin)
  • Using perfstat to improve performance and achieve high machine utilization
  • Finding the happy medium for the granularity of work
  • Write up the report.