Eight two-week units of courseware (slides, lecture notes, samples, tools) for teaching how to program parallel/concurrent applications at a high-level using Microsoft’s Parallel Extensions to the .NET Framework.
Practical Parallel and Concurrent Programming is a semester-long course that will teach students how to program parallel/concurrent applications, using the C# and F# languages with other .NET libraries. We emphasize both performance and correctness. This 16
week (8 Unit) course is aimed at beginning graduate or senior undergraduate students. Individual units can also be taught a la carte.
- This course supports a tool-based approach to correctness and performance. We have developed an attribute-based concurrency unit testing framework called Alpaca (A lovely parallelism and concurrency analyzer). Students will build understanding of correctness
conditions and performance problems through experimentation. Students will regularly analyze their code, including tests of data race detection, deadlock detection, stateless model checking, and linearizability checking. We believe that this tool-based approach
will improve the learning experience by enabling quick and simple experimentation and making debugging less frustrating.
- This course has a breadth-first, productivity emphasis. The course material starts at a high level of abstraction by introducing patterns (Units 1-4). In later units (Unit 5-8), these abstractions are peeled back to expose the underlying primitives (e.g.
- This course emphasizes correctness issues in multi-core shared memory systems. However, a wide breadth of material is covered, including performance pitfalls, message passing, and data parallelism.
In this course, students will develop a vocabulary for reasoning about parallelism and correctness. Students will learn to write parallel algorithms. They will also learn how to analyze parallel and concurrent code for correctness, understand expected invariants,
and explain and fix bugs. They will learn how to predict and test parallel speedups, and explain actual performance bottlenecks.
For a detailed description of the download read the
Overview of Courseware
. In a nutshell, it contains slides, notes, code samples, and
(A lovely parallelism and concurrency analyzer). See
for content available independently of the courseware.
Units 1-4 are available via download. Drafts of other units are available via SVN.
The course targets beginning graduate or junior/senior undergraduate students. We assume students are well versed in object-oriented programming in the Java/C# family and have had introductory courses in operating systems and data structures.
The courseware is divided into eight units (Units 1-8). Each unit contains three to four 1.15 hour lectures. Unit 0 contains the introductory lecture. See the
Overview of Units
for a capsule summary of the units and dependences between the units.
Information for Instructors and Feedback
- We have developed quizzes that can be used to test students understanding of the core concepts in the course. This material is not part of the download. Please contact us at
firstname.lastname@example.org to request the material.
This courseware was developed by the
Research in Software Engineering
(MSR) and the University of Utah, with support from the Parallel Computing Platform team at Microsoft (Stephen Toub, Sherif Mahmoud, Chris Dern) and MSR External Research (Judith Bishop). The main authors are:
The slides contain contributions from many people. See the acknowledgements slide at the beginning of each lecture for attribution.