Credit: This project is based on the project assigned by Brad Chamberlain when he taught this course in 2013.

IMPORTANT: The projects that Brad's students did are posted to the previous website. You may look at them to get an idea of what sorts of projects worked well, but do not under any circumstance copy, paraphrase, or in any way base your projects on their work. I will be checking for this. I suggest you not even look at projects that were based on the same topic as yours, in order to avoid the temptation.

Important Dates:

• April 21st (homework 3 due date): Pick a project topic as part of homework 3
• May 1: Finalize project topic (topic changes after this date are strongly discouraged).
• May 26, June 2 (in class): Oral presentations. Slides (in ppt, pptx, or pdf format) should be emailed to Mike by 5pm the day before, so that I can have everybody's slides on one machine (to minimize presentation switching overhead).
• June 5, midnight: Written reports are due (you are welcome to turn them in the day of your presentation instead of waiting to June 5, if you prefer).

Goals: My goals for this project are:

• To permit you to dig into some aspect of parallel computing that interests you
• To expose the rest of the class to topics I didn't have time to cover
• To give you practice with written and oral presentations

Project Types: There are two basic types of projects. Hybrids are possible as well.

• Reading/Exploration: Learn about some new technology via reading papers, and trying it out if feasible (e.g., download and play with a compiler for a new language). You should probably read 2-4 papers if you are able to try out the technology. If you are unable to try it (e.g., the resources are not publicly available), you should try to read an additional paper that is focused on evaluation.
• Programming Project: Propose some sort of parallel programming project that goes beyond what we’ve done in class. For example, you might implement a parallel algorithm we didn't cover in class, or implement an application in a framework we did not study.

Selecting Project Topics:

• For reading projects, I’ve provided a list (below) of candidate topics for you to consider. Feel free to propose an idea of your own as well.
• For programming projects, you can implement an algorithm (or set of related algorithms) that we did not study, or write an application (or applications) in a framework/frameworks we did not study. One interesting option might be a performance and/or ease of use comparison between different languages/frameworks.

Deliverables:

1. Report: a write-up summarizing your project (roughly 5000-7500 words). For a reading/exploration project, summarize the technology that you’ve learned about in your own words and relate it to technologies we’ve discussed in class. As appropriate, you should express your opinions about what you think is good/bad about a given technology.For a programming project, this should describe the approach you undertook, challenges faced and how you dealt with them, and the results you obtained (e.g., speedup or other forms of evaluation).
2. Presentation: a short in-class presentation summarizing your project. (7-8 minutes followed by a question or two from the audience). The goal of this presentation should be to convey what you’ve learned to your classmates and to Amnon & me, and to teach us all about the topic that you are now the class expert on. This is not a lot of time to present, so be sure to distill what you've learned down to the most important points/what you think we all should know about the topic. Please practice your presentation beforehand - it will go smoother and you'll be able to cover more if you have practiced. The good thing about short presentations is that it doesn't take very long to practice them!!

• IMPORTANT (repeating from above): The projects that Brad's students did are posted to the previous website. You may look at them to get an idea of what sorts of projects worked well, but do not under any circumstance copy, paraphrase, or in any way base your project on their work. I will be checking for this. I suggest you not even look at projects that were based on the same topic as yours, in order to avoid the temptation.
• You need to learn/do something new. For example, if you work on your company’s parallel programming framework, reporting on that technology to the class isn’t a viable project, it’s simply advertising; by contrast, if you work for such a company but have never worked on their parallel framework, learning about it and reporting on it would be a reasonable project if that’s of interest to you. Similarly, any programming project you take on should be an algorithm you’ve never written before and/or in a language you’ve never used before.
• I've heard from previous instructors that group projects are difficult to organize in PMP courses, due to busy schedules. However, if you would really like to do one, and can figure out the scheduling yourselves, I will allow teams of two. Teams of two should plan to go into more depth than single projects. I'd expect the report to be about 50% longer (roughly 7500-10000+ words), and the presentation should be 11-12 minutes.

Possible topics:

I suggest searching for and skimming resources on a topic before committing to it, to make sure there are enough accessible resources available to you.

The following list is based on Brad Chamberlain's list from the last time this course was taught, with a few additions (mainly in analytics frameworks), and a couple deletions. This list is not meant to be exhaustive, but rather to be a sample of possible topics.

Parallel Analytics Frameworks (we will cover Hadoop and Spark in class):

• Apache Storm
• Apache Flink
• Spark modules (we will only cover the Spark core in class):
  • GrpahX
  • Spark SQL
  • Spark Streaming
  • MLLib
• others?

Languages/Programming Models:

• X10 (IBM's competitior to Chapel)
• Fortress (Sun's competitor to Chapel, cancelled in 2012, but still an intersting topic)
• Charm++ (C++-based, distributed memory dynamic OOP-based parallelism)
• XcalableMP (current/modern Japanese HPF/OpenMP hybrid)
• Titanium (Java-based PGAS language)
• CAF-2 (Rice University extensions to Coarray Fortran to make it more flexible)
• HPF (classic failed data parallel language of the 1990's)
• ZPL (UW data parallel language of the 1990's)
• Global Arrays (library-based support for data-parallel distributed arrays)
• NESL (functional nested parallelism language)
• Sisal (functional parallel language)
• Haskell parallelism and concurrency (functional language that supports parallelism and explicit concurrency)
• Sequoia (Stanford language for hierarchical machines)
• Legion (Stanford language for heterogeneous next-gen machines)
• SAC (single-assignment C : functional, C-based data-parallel language from Europe (www.sac-home.org) - not to be confused with SA-C for FPGA programming)
• StreaMIT (MIT streaming language)
• Brook (Stanford streaming language)
• StarSS/OpenSS (dataflow-based languages from Barcelona Supercomputing Center)
• Intel TBB (Intel C++ template library for task parallelism/concurrency)
• Cilk (originally MIT, now Intel, language for task parallelism)
• Microsoft TPL (Microsoft features for parallelism)
• Rust (Mozilla research language for safe task parallelism)
• C++11 support for parallelism
• Erlang concurrent programming (explicit concurrency with message passing)
• Deterministic Parallel Java (UIUC language for writing safe/deterministic parallel programs)
• Apple Grand Central Dispatch (task parallelism with thread pools)
• GraphLab (vertex-centric programming model for large graph problems)
• Pregel/Apache Giraph (vertex-centric programming model similar to MapReduce/on Hadoop)
• Dryad (Microsoft framework for directed acyclic computation graphs)
• Go (Google language) (open Q: are there sufficient parallel features for this to be interesting?)
• MPI-3 extensions (one or more of the following):
  • single-sided communication
  • topology awareness
  • support for threads
  • active messages
  • GPU support

GPU/Accelerator programming models:

• OpenMP 3.1(?) extensions for GPUs/accelerators
• OpenACC (directive-based GPU/accelerator programming; like OpenMP for GPUs)
• CUDA (Nvidia GPU programming model)
• OpenCL (open, community-based GPU programming model)
• MPI-3 research/extensions (?)

Parallel Numerical Libraries:

• Trilinos
• PETSc
• ScalaPack

Architecture - earn about some key architecture in-depth:

• Cray XC/Aries interconnect
• IBM BlueGene
• SGI UV (UltrViolet)
• Cray XMT / Tera MTA
• Dataflow machines (e.g., WaveScalar)
• Hardware Transactional memory in Intel Haswell and/or IBM BlueGene/Q
• other?

Parallel Technologies:

• Lightweight threading packages:
  • Qthreads
  • Nanos++
  • MassiveThreads
• Software Transactional Memory (e.g., STM in the Glasgow Haskell Compiler)
• Dynamic load balancing (e.g., scalable workstealing in Cilk, X10, UPC)

Determinism for concurrent programs:

• Deterministic Execution (e.g., 'CoreDet' ASPLOS 2010, 'DMP' ASPLOS 2009, 'RCDC' ASPLOS 2011, 'Grace' OOPSLA 2009, 'Kendo' ASPLOS 2009)
• Programming models for determinism (e.g. 'Hobbes: CVS for Shared memory', 'Deterministic Parallel Java (DPJ)')

Compilers and parallelism:

• Parallelizing and/or Vectorizing Compilers
• Composing parallel software (e.g. Berkeley 'Lithe', 'Reagents' PLDI 2012)
• Domain specific languages that support parallel execution (e.g. "A Heterogeneous Parallel Framework for Domain-Specific Languages")