Syllabus for CS 598, Concurrent Programming

Summer 2002


The syllabus is divided into six two-week sections:

  1. Concurrent Programming

  2. Locks, Barriers, and Semaphores

  3. Java and Concurrency

  4. Implementing Exclusion

  5. Maintaining Consistent State

  6. Threads
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 - Concurrent Programming, Tuesday, 28 May to Thursday, 6 June.

Readings
Andrews: Chapters 1 and 2

Class notes
A model for concurrent execution.
States and properties.

Assignment
Assignment 1.

Section 2 - Locks, Barriers, and Semaphores, Tuesday, 11 June to Thursday, 20 June.

Readings
Andrews: Chapters 3 and 4

Class notes
Critical sections.
Semaphores.
Semaphore examples.
Split semaphores.
Performance and Concurrency.

Assignments
Assignment 2.

Section 3 - Java and Concurrency, Tuesday, 25 June to Tuesday, 2 July.

No class - Thursday, 4 July

Readings
Lea: Chapter 1

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

Assignments
Assignment 3.

Section 4 - Implementing Exclusion, Tuesday, 9 July to Thursday, 18 July.

Readings
Lea: Chapter 2

Class notes
Programming patterns.
Immutable instances.
One-reference instances.
Mutex locks.

Assignment
Assignment 4.
Code review.
A solution, with discussion.

Section 5 - Maintaining Consistent State, Tuesday, 23 July to Thursday, 1 August.

Drop Day - Wednesday, 24 July

Readings
Lea: Chapter 3.

"Alphonse, Wait Here For My Signal!" by Steven Hartley, SIGCSE Bulletin, pages 58-62, March 1999 (The Proceedings of the Thirtieth SIGCSE Technical Symposium on Computer Science Education).

Class notes
Synchronization utilities.

Programming Assignment
Assignment 5.
A code review.
A solution, with discussion.
Also solutions by Chatterjee and Kallakuri, Doshi and Ramineni, Kallakuri, Mayo and Wiegers, and Wiegers.

Section 6 - Threads, Tuesday, 6 August to Tuesday, 20 August.

Class notes
Monitors.
Communicating Sequential Processes.

Readings
Lea: Chapter 4.

Java's Insecure Parallelism by Per Brinch Hansen, ACM SIGPLAN Notices, pages 38-45, April 1999.

Why Threads Are A Bad Idea (for most purposes) by John Ousterhout.

Analyses
Alphonse (178,688 bytes) by K. Kallakuri and C. Mayo.


This page last modified on 20 August 2002.