Here is a preliminary list of project suggestions. I will continue expanding this until mid-February as suggestions come in.

This is only a list of suggestions. You are free to propose your own project.

You will have access to multicore machines in the instructional network, the Xeon Phi 7290 (on request), and NVIDIA GPUs. You can also (on request) obtain access to parallel machines in CIRC.


Do you have a computational task that takes too long to run? Parallelize it!

Some of these tasks have competitions. Take a look:

Parallelize Experiment-Directed Metadynamics (EDM)

(Text courtesy Rainier Barrett)

In general, simulation of large peptides and proteins poses a challenge because of the wide variety of configurations the system can take, and the large number of interactions among particles. This makes finding a "correct" conformation for some application computationally difficult. These "correct" conformations are important for applications in things like drug discovery and design, and other areas. By observing the physical behavior of these molecules with simulations, we can learn things about them that experiments cannot capture.

Experiment-Directed Metadynamics is a technique that allows us to bias a force-field-generated potential for a molecular dynamics simulation using an experimentally-observed free energy surface along some collective variable (a function of atom positions). SAXS is one such measurement we could use to help ensure that the physics of an EDM-biased simulation maintains some physical qualities that are experimentally confirmed beforehand. [Contact Rainier Barrett or Prof. Andrew White]

  • Project 1: Parallelize the EDM algorithm
  • Project 2: Parallelize an approach for calculating SAXS data in molecular dynamics simulations. This is typically done by meshing particles to a 3D grid, performing a fast Fourier transform of the mesh, and then calculating I(Q) via the Debye formula: 1, e.g. 2, 3.

Parallelize a Particle Solver from the Lab for Laser Energetics

(Text courtesy Prof. Adam Sefkow)

Intense lasers generate plasma conditions during the implosions of our targets. To properly model how the plasma behaves in the presence of fields and accounting for non-fluid effects, we have to use a particle kinetic model like this.

The main program (source) is "es.i" and the "potsolv.i" file is the potential solver. This is a very simple 2D problem of plasma flowing past a charged plate. The potential solver is in the latter file. The code is similar to C, but actually run in the program yorick (SourceForge, GitHub) So it would first need to be translated pretty straightforwardly into C.

The project would be:

  1. Translate into serial C code,
  2. Parallelize the "particle pusher" and "field/potential solver".

Parallel Data Structures

More projects to be added

Cache-Conscious Concurrent HAMT (Hash Array Mapped Trie) in Rust (Prof. Chen Ding)

Study the Ideal Hash Trees paper by Phil Bagwell and concurrent HAMT design/implementation in Scala. Write your own and use an existing HAMT implementation in Rust. Make it concurrent, if it isn’t already so. Make a cache-conscious by re-locating the data items stored in the map based on how they are accessed. Evaluate the performance and scalability on very large data sets (near the memory size of the testing machine). [Please contact Prof. Chen Ding for details]

Parallel Runtime Support

Safe Parallel Memory Allocation in C (Prof. Chen Ding)

Test and evaluate Benjamin O’halloran’s inter-process allocator (IPA, IPA is an allocator that enables multiple processes to allocate and free concurrently to non-conflicting regions of virtual memory and then merge or undo the results after the parallel execution. It is written in C and makes direct requests to OS primitives such as mmap and sbrk. Contact the author (he’s working at Facebook) for his undergraduate thesis for a description of the design. This project may lead to a publication since IPA is not published, because of the lack of a scientific evaluation. [Please contact Prof. Chen Ding for details]

Domain-specific Parallel Programming Models

Domain-specific languages (DSLs) are programming languages that are restricted to specific domains. This not only allows them to be easier to program in, but also provides higher-level semantics which can be exploited for parallel execution.

Here are some examples of domain-specific languages that have already been parallelized to give you an idea:

  • Halide, a language for high-performance image processing
  • Tensorflow/XLA, a domain-specific language for linear algebra
  • IrGL, a language for irregular computations (such as graph processing).

Note that "languages" is used loosely here. You can even embed the language as a runtime in another language (such as C++). Even libraries can qualify as languages.

Distributed Systems

Use a decentralized protocol (e.g. DAT) to build something interesting.

Projects to be added

More ideas

Professor Michael Scott maintains a list of projects which can be used as a project for this class, please contact him directly.

Professor Sandhya Dwarkadas is interested in a project involving transactional memory, please contact her directly.