Languages/Programming Models
----------------------------

* X10 (IBM's competitior to Chapel -- more Java/Scala-like; themes:
  "async-finish" task parallelism, "phasers" synchronization)

* Fortress (Sun's competitor to Chapel -- next-gen language by Guy
  Steele (Java) -- themes: functional; parallel-by-default; language
  defines "nothing", library defines everything)

* 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 CAF to make it more flexible)

* HPF (classic failed data parallel language of the 1990's)

* ZPL (UW data parallel language of the 1990's -- we'll likely cover a
  bit in class, but there's more than we'll be able to get to)

* Global Arrays (library-based support for SPMD distributed arrays)

* NESL (functional nested parallelism language)

* Sisal (functional (data?) parallel language)

* Haskell parallelism and concurrency (functional language that
  supports parallelism and explicit concurrency)

* Phalanx (Nvidia C++-based programming model for heterogeneous
  next-gen machines)

* 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
------------
Learn about some key architecture in-depth:

* Cray XC
* IBM BG/Q (BG/P, BG/L, ...)
* SGI UV
* Cray XE/XK/XT
* Cray XMT / Tera MTA
* Dataflow machines (e.g., WaveScalar)
* The Vector Thread Architecture (unifying vector and multithreaded models)
* 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")