We normally have two classes per week, one on Monday and one on Wednesday, both at 10:00–11:45. See below for a more precise schedule, where there is no lecture on dates corresponding to cells with greyed out text or no text. See the official schedule on TimeEdit for information about the rooms.
We will try, to the extent possible, to make the slides/lecture notes available online on this page the day before each class. However, this is not guaranteed to always happen, and in any case a new version of the slides may be uploaded after class according to what has actually been presented. Therefore, we encourage you to take notes independent of the slides material available before class.
|15||16 October 2017||Models and languages of concurrent computation||
|14||13 October 2017||Verification of concurrent programs||
|13||9 October 2017||Software transactional memory||
example source code
|12||2 October 2017||Parallel linked lists||
examples source code
|References: Herlihy & Shavit 9.|
|11||29 September 2017||Parallelizing computations||
examples source code
|References: Herlihy & Shavit 16.1, 16.4.|
|10||25 September 2017||Examples of message passing programs||
message passing tutorial
|Notes: We present examples of programming with message passing. Chap 8 of Ben-Ari does not provide many examples of parallelism, or programs with dynamic structures, so our examples may be useful. As in our tutorial before the first lecture, the examples are in Promela so you can experiment with the code on SPIN. Please take notes in class, as the programs are documented very tersely. In class, we will also talk about which of these programs (which use channels) can be coded in Erlang (no channels), and how.|
|9||22 September 2017||Reasoning about Monitors and Protected Objects||
slides (monitors & protected objects)
|Notes: Material from Chap 7 of Ben-Ari. If time permits, we will take a first look at Chap 9, on spaces.|
|8||18 September 2017||The material in Chap 3 of Ben-Ari||proofs tutorial||
Notes: We will study “hardware processes” (which do busy-waiting instead of blocking), and study several attempts to solve the Critical Section (CS) problem without special atomic hardware instructions. We do proofs using both state diagrams and the program text.
Claims about state diagrams can be confirmed or debugged by a model checker, but these tools cannot say why a claim holds. That insight helps when modifying the program, and is given by proofs about a program from its text. A mechanical checker for such proofs would help, but, oddly, there are not very many proof checkers for concurrent programs. A first version of one was developed for a bachelor’s thesis by students from this course last year:
|7||15 September 2017||Erlang tutorial||notes||This will be a hands-on session going through the Erlang language, including everything you need to get started with the CCHAT lab. It is recommended that you look through the notes before the tutorial.|
|6||11 September 2017||More on FP concepts and message passing||
Notes: Today we will look at the concurrency chapters of the Erlang resources
If time permits, we will also do some examples in Ben-Ari’s textbook notation (the slides we use will be put up later).
|5||8 September 2017||Introduction to Message Passing||slides||Notes: We postpone further study of examples and proofs of shared memory programs, whether hardware, semaphores, monitors or protected objects. I.e., chaps 3 – 7. We start message passing today to prepare you for Lab 2. This topic is in Chap 8 of Ben-Ari, but in coming lectures, we will try to do more examples than he gives.|
|4||6 September 2017||Monitors and protected objects||slides||
Notes: We spent time figuring out invariant based proofs for bubble sort, for a linear program to extract the largest element in an array, and for the grid game with one player trying to make a closed circuit, and the other trying to prevent this.
We then looked at the design motivations for monitors and protected objects.
We also studied closely the state transition diagram for critical section with semaphores. What states are present/absent, and what invariant properties we can see in it.
|3||4 September 2017||Invariants and Semaphores||slides||
|2||1 September 2017||Introduction to programming with semaphores||slides||
Notes: Mostly chap 6 of Ben-Ari, but without treatment of invariants. We also use the test-and-set instruction from Chap 3, and the definition of critical section problem there.
Java Concurrency Examples: You can download the Java examples described in the second part of the lecture here.
|1||28 August 2017||Introduction to principles of concurrent programming||slides||
Notes: The first goal is to read Chap 6 of Ben-Ari, using only the minimum needed from the earlier chapters. We should reach this by the next lecture. The first idea is to find the software equivalent of an atomic action, with sleep state instead of busy wait, so it works for abstract processes instead of CPUs.
Assignment: Make enough progress with an Erlang tutorial to see if you can manage sequential programming. That will tell you whether you can manage the FP needed.
If you want to get an idea of the material covered in the course before, here are the lecture notes used in previous editions of the course: