Advanced Topics in Concurrent Programming

Computer Science Seminar,  236832,  Spring 2022

Instructor: Erez Petrank, erez@cs, office: Taub 528. Phone: 829-4942.

Announcements:

• On Wednesday June 22nd talks will be held on Zoom, with link shared by email. See you on Wednesday, virtually.
• Unfortunately, my airlines failed to deliver me back and I will not be able to hold class this Sunday. Instead, we will hold the class following the regular class on Wednesday. Namely, Wednesday June 22nd, 12:30--14:30. Due to the late notice, presence at that talk will be not be compulsory, although you are cordially invited to attend. See you next Wednesday.
• Due to travel, the 11th talk is rescheduled (from June 15th) to June 19th, Sunday 16:30--18:30.
• This year there were too many requests to register (more than 3x as many as I could accept). I apologize to all the excellent students that could not register. Students I could enroll are listed on this page.
• The schedule of the talks is as explained in the bottom item below. But if COVID allows travel and conferences become physical, I might need to travel and miss the 11th lecture on June 15th. A replacement lecture will take place on Sunday the 19th. I will know better at least a month ahead of the lecture.
• See registration instructions at the end of the page.
• There exists an errata file with known errors in the book. If your lecture is from the book, please take a look at it.
• About the schedule of the talks: the students who will register will pick about 19 of the (unassigned) topics below. Each selected topic will be given in a single class (50 minutes), meaning 2 topics a week. So the exact timing of a lecture will be determined only when all registered students will pick their topics, which will probably only happen at the first week on the semester. But the order between talks is as listed below.

Topics:

Introduction (all talks in this section are taken from the Art of Multiprocessor Programming by Herlihy & Shavit available at the library):

1. Introduction to Concurrency: hardware and software, see Appendix A and B of the book. Assigned to Elad Kinsbruner. Presentation (March 30)
2. "Spin locks and contention in practice", chapter 7 in the book.  Assigned to Arad Kotzer. Presentation (March 30)
3. "Monitors and Blocking Synchronization",  chapter 8 in the book. Assigned to Tamir Daniel. Presentation (April 6)
4. Properties of concurrent computation: correctness and progress, chapter 3 in the book.  Assigned to Erez Petrank. Presentation (April 6)

Concurrent Algorithms (several talks in this section (those referenced as "chapter n") are taken from the Art of Multiprocessor Programming by Herlihy & Shavit available at the library):

5. Linked Lists: the Role of Locking, chapter 9. Assigned to Erez Petrank. Presentation () (April 13)
6. Concurrent Queues and the ABA Problem, chapter 10. Assigned to Jonathan Ziskind. Presentation (April 27)
7. Wait-free Queues (paper). Assigned to Hen Kas Sharir. Presentation (April 27)
8. Concurrent Stacks and Elimination, chapter 11. Assigned to Tomer Adar. Presentation (May 2)
9. Counting, Sorting, and Distributed Coordination, chapter 12. Assigned to Itay Eilat. Presentation (May 2)  
10. Concurrent hashing and natural parallelism, chapter 13. Assigned to Yosef Goren. Presentation (May 18)
11. Skiplists and Balanced Search, chapter 14. Assigned to Hod Badichi. Presentation (May 18)
12. "A Skiplist-Based Concurrent Priority Queue with Minimal Memory Contention", (paper). Assigned to Omer Yerushalmi. Presentation (May 25)
13. Futures, Scheduling, and Work Distribution, chapter 16.
14. Barriers, chapter 17. Assigned to Nadav Adir.>Presentation (June 1)
15. "Flat Combining", (paper). Assigned to Yonatan Medan. Presentation (June 1)
16. "Lock-Free Snapshots", (paper). Assigned to Lior Cohen. Presentation (May 25)
17. "Lock-Free Snapshots by multiversioning", (paper).

Memory Management for lock-free Data Structures:

20. Hazard pointers (paper). Assigned to Erez Petrank. Presentation (June 8)
21. Optimistic access (paper). Assigned to Erez Petrank. (June 8)
22. IBR: Interval Based Reclamation (see paper).
23. Hazard Eras - Non-Blocking Memory Reclamation (see paper). Assigned to Alon Kitin. Presentation (June 19)
24. NBR: neutralization based reclamation (see paper). 
25. VBR: Version Based Reclamation (see paper).

Debugging:

30. Debugging tools: Microsoft's Chess (paper). Assigned to Yaniv Goft. Presentation (June 29)
31. IBM’s synchronization coverage for testing (see paper). 
32. A Randomized Scheduler for Bug Finding (see paper). Assigned to Amir Bishara. Presentation (June 22)
33. Deterministic parallelism (see paper). Assigned to Avidan Borisov. Presentation (June 22)
34. Record-Replay parallel executions (see paper) 

Systems Scalability:

40. An Analysis of Linux Scalability to Many Cores. (see paper). Assigned to Yaniv Holder. Presentation (June 29)

Concurrent data structures on GPUs:

45. Performance Evaluation of Concurrent Lock-free Data Structures on GPUs. (see paper). Assigned to Ella Sheory. Presentation (June 19)
46. Mega-KV: a case for GPUs to maximize the throughput of in-memory key-value stores. (see paper).

Concurrent data structures on non-volatile memory:

50. A persistent lock-free queue for non-volatile memory. (see paper).
51. Log-Free Concurrent Data Structures. (see paper).
52. Efficient Lock-Free Durable Sets. (see paper).
53. The Inherent Cost of Remembering Consistently. (see paper).
54. Mirror: making lock-free data structures persistent. (see paper).
55. Dalí: A Periodically Persistent Hash Map. (see paper).
56. A Fast, General System for Buffered Persistent Data Structures. (see paper).

Grading

• Lecture (at least 85%),
• Participation (at most 15%),
• Reduction of 5 points for each (unjustified) absence.
• Each justified absence requires summary of missed lecture.
• The talk will be graded by: Knowledge of the material, Slides effectiveness, Communication of the ideas, and working within the time limit of 50 minutes.
• Main goal: make people understand!

Administrative

• Course syllabus (in Hebrew)
• Prerequisites: Algorithms 1 (234247)  and  Operating Systems (234123). Further knowledge in concurrent systems will help to understand the topics presented.
• Reception hours: TBD. (If this is not a good time for you, contact me by email to schedule an alternative.)

Material Covered in the Seminar:

The day that every (new) computer employs parallel processing has arrived. But writing concurrent programs is notoriously difficult and a large amount of traditional sequential code exists. A major challenge to the industry and (applied) research today is to find ways to make the programming for concurrent systems easier and accessible for all programmers. We will present concurrency programming setting, discuss several concurrent data structures, and present server architecture. Another major challenge is the debugging and more generally the reliability of concurrent programs. Some bugs only appear infrequently under specific scheduling scenarios. What are the right tools to discover such bugs and fix them? What are the tools to verify that a code is correct? More challenges relate to progress guarantees, specifically, lock-freedom. In this seminar, we will discuss some of these questions and check which answers exist today.

Assignments:

Each student will prepare a talk on one of the topics above.   

Course Registration:

Registration is manual and we will attempt to match the registered students with the seminar topics. Please send an email to the lecturer (erez@cs) with your name, student id, grades transcript (תדפיס ציונים), and relevant experience in industry or lab projects. In addition, let me know if you can come to class physically to attend the seminar (in case the authorities allow physical teaching), or whether you cannot come to class, e.g., because you have special COVID conditions that prevent you from coming.

The final list of registered students will be determined after the first lecture in the beginning of the spring semester.