Syllabus for CS 598, Concurrent Programming

Summer 2003


The syllabus is divided into eleven one-week sections:

  1. Introduction

  2. Processes and Synchronization

  3. Locks and Barriers

  4. Semaphores

  5. Java and Concurrency

  6. Implementing Exclusion

  7. Maintaining Consistent State

  8. Threads

  9. Monitors

  10. Modeling

  11. Higher-Level Concurrency Mechanisms
The general outline of the syllabus shown below will not change, but the details may vary as circumstances evolve. You should get in the habit of checking the syllabus regularly.

Section 1 - Introduction, Tuesday, 27 May to Thursday, 29 May.

Readings
Andrews Chapter 1

Class notes
An introduction to concurrency.
Concurrency and architectures.
Concurrent programming notations.
Concurrent programming.

One-minute reviews
27-29 May

Section 2 - Processes and Synchronization, 3-12 June.

Readings
Andrews Chapter 2

Class notes
Computations.
Interference.
Avoiding interference.
Atomicity and synchronization.
Saftey, liveness, and fairness.

One-minute reviews
3-5 June
10-12 June

Section 3 - Locks and Barriers, 17 & 19 June.

Readings
Andrews Sections 3.1 through 3.3
Andrews Sections 3.4 through 3.6 (optional)

Class notes
Critical sections.
Implementing critical sections.
Using critical sections.

One-minute reviews
17-19 June

Section 4 - Semaphores, 24 & 26 June.

Readings
Andrews Chapter 4

Class notes
Semaphores.
Using semaphores.

One-minute reviews
24-26 June

Section 5 - Java and Concurrency, 1 & 3 July.

Readings
Lea: Sections 1.1, 2.2, and 3.2

Class notes
Java threads.
Java synchronization.
The Java memory model.
Thread interrupts.

One-minute reviews
1-3 July

Programming Assignment
Assignment 5 available (last modified on 7 July 2003) on 1 July, due on 8 July at 2:00 p.m..

Section 6 - Implementing Exclusion, 8 & 10 July.

Readings
Lea Sections 2.1, 2.3, and 2.5

Class notes
Immutable instances.
One-reference instances.
Locking.

One-minute reviews
8-10 July

Section 7 - Maintaining Consistent State, 15 & 17 July.

Readings
Lea: Sections 3.1 through 3.5

Class notes
Synchronization utilities.
Failure and termination.
Locking structures.

Programming Assignment
Assignment 7 available (last modified on 22 July 2003) on 15 July, due on 22 July at 2:00 p.m..

Section 8 - Threads, 22 & 24 July.

Drop Day - Wednesday, 23 July

Readings
Lea: Sections 4.1, 4.3, and 4.4

Class notes
One-way messages.
Asynchronous request-response.
Parallel decomposition.

Section 9 - Monitors, 28 & 30 July.

Readings
Andrews: Chapter 5

Class notes
Monitors.

One-minute reviews
28-30 July

Section 10 - Modeling, 5 & 7 August.

Readings
David Harel, On Visual Formalisms, Communications of the ACM, May 1988.

Class notes
The .NET memory model.
State machines and statecharts.

One-minute reviews
5-7 August

Programming Assignment
Assignment 10 available (last modified on 22 July 2003) on 5 August, due on 12 August at 2:00 p.m..

Section 11 - Higher-Level Concurrency Mechanisms, 11 & 13 August.

Readings
Carriero and Gelenter, How to Write Parallel Program: A Guide to the Perplexed, ACM Computing Surveys, September 1989

Benton and Cardelli, Introduction to Polyphonic C#.

Class notes
Tuple spaces.
Polyphonic concurrency control.

One-minute reviews
11-13 August


This page last modified on 20 August 2003.