• Terminology
• Official Java tutorials on concurrency
• Java bytecode instruction set. This is only interesting if you want to inspect the bytecode of a compiled Java program. This can be done with javap -c path/to/MyClass.class on the command line or online at https://godbolt.org/.
• List of Java Thread states and their meaning

• Overall, "The Art of Multiprocessor Programming" is a very very good resource for this part of the course. It is very well written and covers almost all topics of the lecture in depth.
  • Chapter 2 (p. 21): Covers the mutual exclusion algorithms from the lecture, with proofs.
  • Chapter 7, 7.1-7.4 (p. 141): Covers TAS, TATAS and exponential backoff locks.
  • Chapter 8 (p. 177): Covers monitors, semaphores and the readers-writers lock, but a bit differently to the lecture.
  • Chapter 9 (p. 195): The content on lock granularity from the lecture is based on this chapter in the book and follows it very closely. The book is a nice reference here especially for implementations of the algorithms.
  • Chapter 10, 10.5-10.6 (p. 230): Covers the implementation of a lock-free unbounded queue and the ABA problem, using the queue as an example.
  • Chapter 3, 3.1-3.6 (p. 45): Covers sequential consistency and linearizability (and quiescent consistency, but this is not exam relevant). The proofs starting from 3.6.2 were not covered in the lecture (and are hence of course not exam relevant). Good to know: the book always lists the linearization points of code given later chapters.
  • Chapter 5, excluding 5.1.1 and 5.5-7 (p. 99): Covers consensus. Proofs like for theorem 5.2.1 or 5.4.1 are not exam relevant.
  • Chapter 18 (p. 417): Covers transactional memory. Parts of the chapter go a bit more in depth into implementation details that were not covered in the lecture.
• Resources on the Java memory model:
  • Short summary of happens-before from the Java documentation.
  • Official paper explaining the memory model. It should be understandable. Alternatively, you can read the official specification, which is more compact but has less explanations. If you choose the specification, I can recommend reading up to and including section 17.4.5.
  • A nice talk on the Java memory model.
  • Chapter 16.1 (p. 337) of the book "Java Concurrency in Practice" has an explanation of the Java memory model.
  • An introductory blog article on memory models in general.
• Resources on MPI:
  • The MPI standard.
  • If you want to understand the difference between synchronous/asynchron or blocking/non-blocking better, I can recommend sections 3.4 and 3.7 of the standard (there the "standard" communication mode for send is what we call asynchronous).
  • Documentation of the different MPI operations. The descriptions should be helpful, e.g. here is the one for MPI_Allgather.
  • Blog articles on collective communication and scatter, gather and allgather.

Locks

• true/false questions of which lock has which properties (fairness, starvation free)
• find bug in lock code (violation of mutual exclusion or deadlock freedom)
• draw state space diagram and/or read off correctness properties
• reproduce Peterson/Filter/Bakery lock
• prove correctness of Peterson lock or similar (but not Filter or Bakery)

Monitors, semaphores, barriers

• semaphore implementation (mostly with monitors)
• (never seen rendezvous with semaphores in an exam)
• barrier implementation (mostly with monitors)
• (only seen a task on implementing a barrier with semaphores once in FS21, 8b)
• fill out some program using monitors (similar to wait/notify exercises, maybe with lock conditions)

• Consensus:
  • I have a strong feeling that the head TA wants to ask this in the exam. ;)
  • I can think of three types of questions on this topic: short questions on the definitions, identifying whether given code is a correct consensus protocol or making a statement about the consensus number of an object. For the latter, I only see two options:
    1. Proving that an object x has consensus number
       $\ge y$
       (or
       $\infty$
       ). Then you must provide an algorithm solving
       $y$
       -thread consensus using any number of instances of x (or for the
       $\infty$
       case, provide an algorithm solving
       $n$
       -thread consensus for arbitrary
       $n$
       ).
    2. Proving that an object x has consensus number at most
       $z$
       . This would involve proving that it is impossible to implement
       $(z + 1)$
       -thread consensus with x. With the content of the lecture, the only option I see is to use the theorems that were shown. For example, if we know that x was implemented using atomic registers, then it cannot solve consensus for more than one thread. Proofs that do not rely on such results require some concepts that were not covered in the lecture. (An example is the proof for why atomic registers cannot solve 2-thread consensus in "The Art of Multiprocessor Programming" (p. 103).)
    So I would recommend to practice writing consensus protocols and revising the results from the lecture.
• MPI: Since the topic was only covered in short time in the lecture and no exercises were provided on the topic, I would not expect coding exercises with MPI in the exam (again, cannot promise). But that does not exclude reading and understanding MPI code. I would make sure to remember what the collective operations do, as this has been asked before.