CS533 - Advanced Operating Systems

When: Mon/Wed 1000-1120
Where: FAB 150
Instructor: Jonathan Walpole
Instructor Office Hours - By Appointment

If you are signed up for this class, please send me your email address!

Description

This is an advanced graduate course focussed on synchronization-related topics in operating systems. The course is based on research papers, and will involve a lot of reading and assimilation of ideas. The reading list has been carefully selected from classical and recent research papers in order to introduce and develop the key concepts and developments in synchronization and shared memory multiprocessor operating system design. These concepts include various uses of locking in OS kernels, synchronization in interrupt and process contexts, issues in the design of scalable spin locks, scalable reader-writer locking, lock-free and non-blocking synchronization, software transactional memory, hazard pointers, read copy update, memory consistency models and their implications for the performance and correctness of synchronization, tools and techniques for checking for bugs in synchronization-related kernel code.

You will be required to read each paper carefully, write a brief summary of it, and submit it before the start of each class. Each student will be assigned one or more papers to present in class. These presentations, your in-class participation and paper summaries will contribute directly to your grade. The goal of this class is not only to help you learn about different systems, but also to learn how to read and evaluate a research paper, how to compose a concise summary of a research paper, and how to synthesize concepts and ideas across several papers. Toward the end of the class each student will write a short position paper describing their views on the current and future directions of operating systems research, particularly in so far as they relate to the topics covered in class.


Prerequisites

If you have not taken, and passed with a grade B or better, an introductory course in operating systems this is not the course for you! Take CS333 first. Ideally, you will also have taken and passed CS533 with a grade of B or better.


Text Book

There are no required text books for this class. Instead, the class is based on a collection of research papers, listed below in the Schedule & Syllabus section.


Grading

Your final grade will be calculated as follows: paper reviews - 20%; in-class paper presentations - 50%; position paper - 30%;


Paper Reviews

Prior to each class, starting with class 2, you must submit a concise review of each of the papers listed for that class. Reviews should briefly explain, for example, (a) what the topic of the paper is, (b) what the contribution is and what problem it solves, (c) how the proposed solution differs from previous work, and in particular how it relates to papers covered so far in this class, (d) how the claims of the paper were validated, i.e., what research methodology was used, (e) whether the paper succeeded in solving an important problem and whether the validation was convincing, (f) what the overall message of the paper was and what aspects of it you found most interesting. Reviews should be written in plain text format and submitted by email to walpole@cs.pdx.edu with subject heading [Paper Review]. Be sure to include your name with your review.


Presentations

Each class session will involve a paper presentations made by a student, followed by a discussion session, led by me, to integrate and evaluate the key concepts. You will be assigned at least one paper (probably several) to present in class during the quarter. Preliminary assignments are listed below each paper. Presentations should be targeted to last 40 minutes and should emphasise the key ideas of the paper. Don't waste your presentation time on mundane issues. You must extract the important contributions and present them clearly. Be sure to work through examples where possible. Your presentation should be formal, and you should prepare slides as necessary. If you reuse material from the web, be sure to cite the source. You must do whatever additional background reading is necessary to enable you to understand and present your paper well. I advise you to start preparing for your presentations early!


Position Papers

Each student must write a short position paper (1500 words) discussing current trends in multiprocessor operating system sttructure and synchronization and predicting future research challenges and likely developments. This paper will be due at the start of class 19.


Mailing List

A "MailMan" e-mailing list will be maintained for this class. The list, called cs510AOS@cecs.pdx.edu, is for communicating information relating to the course, and can be used by students as well as the instructor. All students should subscribe to this list. Go to the following web page and follow the instructions:

https://webmail.cecs.pdx.edu/mailman/listinfo.cgi/cs510AOS


Schedule & Syllabus
Class 1
04-03-06
Course Overview and Review of Kernel Locking Techniques
Overview of the course, plus a discussion of various forms of lock-based synchronization used in OS kernels. A case study of the locking primitives used in the Linux kernel.

Reading:
Class 2
04-05-06
Spin Lock Performance Considerations
Implementation strategies for spin locks, with emphasis on contention issues and design strategies that improve performance.

Reading:
Class 3
04-10-06
Reader-Writer Spin Locks
Techniques for exploiting locality in order to improve scalability of conventional and reader-writer spin locks.

Reading:
Class 4
04-12-06
Communication and Synchronization Strategies for SMMP Kernels
Implications of interrupt-level vs process-level execution and the use of remote access vs remote invocation for communication across processors in shared memory multiprocessor kernels.

Reading:
Class 5
04-17-06
Locality Issues in Scalable Kernel Design
Locality issues, object distribution and replication, scalable locking and interaction with memory management.

Reading:
Class 6
04-19-06
Lock-Free Synchronization in the Synthesis Kernel
Lock-free synchronization strategies for common kernel data structures, kernel design based on extensive use of lock-free synchronization and other strategies to improve locality.

Reading:

Class 7
04-24-06
Non-Blocking Synchronization in the Cache Kernel
General strategies for non-blocking synchronization based on double compare and swap (DCAS) and their use in an OS kernel.

Reading:
Class 8
04-26-06
Practical Blocking and Non-Blocking Queue Algorithms
Practical blocking and non-blocking queue algorithms using Compare and Swap (CAS). Effects of preemption on performance of locking and non-blocking synchronization.

Reading:
Class 9
05-01-06
Preemption-Safe Locking vs Non-Blocking Synchronization
Performance comparison of preemption-safe locking and non-blocking synchronization for various tasks.

Reading:
Class 10
05-03-06
General Methods for Non-Blocking Synchronization
A general methodology for converting sequential objects to non-blocking objects, interactions with memory management.

Reading:
Class 11
05-08-06
Safe Memory Reclamation for Lock-Free Objects
The use of "hazard pointers" for safe memory reclamation with lock-free objects.

Reading:
Class 12
05-10-06
Comparison of Deferred Reclamation Strategies
Comparison of hazard pointers and read copy update (RCU) based deferred reclamation strategies, and performance implications on modern CPU architectures.

Reading:
Class 13
05-15-06
Memory Consistency Models
Memory consistency models of modern CPUs, sequential consistency, weak consistency models, memory barriers.

Reading:
Class 14
05-17-06
What Memory Model Does the Programmer See?
Correctness implications of compiler and architecture-level reordering when concurrency is implemented outside the compiler (i.e. through a thread-library).

Reading:
Class 15
05-22-06
RCU Case Study
Case study of the RCU API with discussion of correct use and mis-use of primitives.

Reading:
Class 16
05-24-06
Using Compiler Extensions to Detect Programming Errors
Meta-level compilation, use of compiler extensions to detect higher level (domain-specific) errors, application to rules for correct use of locking and interrupt disabling.

Reading:
Class 17
05-31-06
Transactional Memory
The transactional memory abstraction as a means of simplifying concurrent programming.

Reading:
Class 18
06-05-06
Software Transactional Memory
Comparison of various software implementations of Transactional Memory.

Reading:
Class 19
06-07-06
Improving the Performance of STM
Weakening the properties of STM in order to allow better performance.

Reading:

Position paper due today!


Back to Jonathan Walpole's home page