CS533 - Concepts of Operating Systems
Fall 2014

When: Monday/Wednesday 16:40-18:15
Where: ASRC 215
Instructor: Jonathan Walpole
Instructor Office Hours - By Appointment
Teaching Assistant: Kendall Stewart
TA Office Hours - Wednesday 11-12:50 Fishbowl(FAB 120) and by appointment


This course is an overview of operating systems concepts for graduate students. 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 operating systems. These concepts include thread-based concurrent programming; classical and modern approaches to synchronization; event-based system design; a comparison between threading and event-based approaches to building operating systems; local and remote message passing; remote procedure call; operating system structuring using a layered approach; micro-kernels and safe extensibility using hardware-based protection; software-based approaches to safe extensibility; virtualization; and general advice for system designers.

Students are required to read each paper carefully, write a summary of it, and submit it before the start of each class. The goal of this class is not only to help students 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.

The course will also involve a substantial programming project in which students will implement a user-level threads library, threads scheduler, and various synchronization mechanisms. The goal of this project is to give students hands on experience with a concrete implementation of some of the concepts covered in the class.


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. We will hold an exam on the first day of class to evaluate whether you have the necessary background knowledge to embark on this course. If we judge that you do not have the necessary background you will be redirected to CS333 so that you can gain the necessary background before coming back to CS533 in a later term. You will be expected to take CS333 for credit, and pass it with a grade of B or better, before coming back to CS533.

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.


Your final grade will be calculated as follows: paper reviews - 20%; midterm exam - 25%; project - 30%; final exam - 25%;

Paper Reviews

Prior to each class, starting with class 2, you must submit a 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 problem it solves, and (most important) the key technical contributions it makes in order to solve the problem, (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. It is important for your reviews to contain sufficient technical detail that you could use them to refresh your memory about the important contributions of the paper rather than having to reread the paper itself. For example, you might use your reviews to prepare for the midterm and final exams.

Reviews should be written in plain text format and submitted by email to walpole@pdx.edu with subject heading [CS533 Paper Review]. Be sure to include your name with your review.


There will be a series of programming projects in which students will implement user-level threads, thread switching mechanisms, a threads scheduler, and synchronization mechanisms. This project will use Linux on a multiprocessor system, and will involve coding in C and x86 assembly language. The projects may be done individually or in groups of 2. More details are available here:

CS533 Course Project

Mailing List

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


Schedule & Syllabus
Class 1
Course Overview and Entrance Exam
In class written exam to ensure that all students embarking on this course have adequate knowledge of Operating Systems concepts at the undergraduate level. If you do not have adequate knowledge you will be advised to defer taking this class until after you have successfully completed CS333. You will complete this material by dropping CS533 and instead taking CS333.

Class 2 and 3
Threads and Concurrency
Review of answers to the entrance exam. Review of the thread concept; concurrency and the need for synchronization; complexity of concurrent programming.

Reading: Useful Links:
  • An introduction to multi-threaded programming based on sequential consistency and data-race-free concepts, by Hans Boem of HP Labs.
  • A tutorial on Pthreads (POSIX Threads) programming from LLNL.
Class 4
Event-Based Systems
Steps toward automatic detection of race conditions, the case against thread-based programming; the reactive programming model; event-based programming.

Class 5
Duality of Threads and Events
The performance and load management implications of thread-based vs event-based programming; the duality of event-based systems and thread-based systems; the case against event-based programming.

Class 6
Integrated Task and Stack Management
Relationship between task management and stack management; Managing state across blocking I/O calls; Cooperative task management with automatic stack management; Integration of legacy code that uses both manual stack management and automatic stack management;

Class 7
Scheduler Activations and RPC
Kernel support for user-level cooperative threading on shared memory multiprocessors. Design and implementation issues for remote procedure calls (RPC).

Class 8
RPC Implementation on Shared Memory Multiprocessors
Optimization of RCP for cross-address-space local communication. How to implement RPC efficiently on a shared memory multiprocessor among user-level threads in different address spaces.

Class 9
System Structuring Using Layers
The advantages and disadvantages of layering as a kernel structuring approach.

Class 10
Modular operating systems; implementing operating system server modules as user level processes that interact via IPC; micro-kernel based OS architectures and abstractions.

Class 11
In Class Midterm Exam
Class 12
Improving Micro-Kernel Performance
Strategies for improving IPC performance in micro-kernel operating systems that utilize hardware-based protection; analysis of potential performance improvements and their impact on higher level performance at the OS and application level.

Class 13
Software-Based Protection for Improving Micro-Kernel Performance
Alternatives to hardware-based protection for structuring operating systems; implementing protection at the assembly language level; supporting operating system extensibility and safety using high-level language support. Virtual machines; supporting multiple operating systems simultaneously on a single hardware platform; running one operating system on top of another. Reducing the software engineering effort of developing operating systems for new hardware architectures. (select two of the following three papers)

Class 14
Virtual machines; supporting multiple operating systems simultaneously on a single hardware platform; running one operating system on top of another. Reducing the software engineering effort of developing operating systems for new hardware architectures. True or pure virualization. Para virtualization; optimizing performance of virtualization system; hypervisor call interface.

Class 15
Exo-kernel concept; minimal operating system functionality; separation of mechanism and policy; techniques for implementing application specific handlers; dynamic specialization of packet filters.

Class 16
Synchronization and Scalability on Multiprocessors
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.

Class 17
Spin Lock Scalability
Implementation strategies for spin locks, with emphasis on contention issues and design strategies that improve performance and scalability.
Class 18
Implications of Compiler Reordering
Discussion of the correctness implications of compiler and architecture-level reordering when concurrency is implemented outside the compiler (i.e. through a thread-library).
Class 19
Memory Consistency Models
Memory consistency models of modern CPUs, sequential consistency, weak consistency models, memory barriers, and implications for performance and scalability.
Class 20
Scalability Issues on Multiprocessors
Design of operating systems for high scalability on multiprocessor systems: locality issues, object distribution and replication, scalable locking and interaction with memory management.

Back to Jonathan Walpole's home page