CS533 - Concepts of Operating Systems
Fall 2015

When: Monday/Wednesday 1400-1515
Where: HOFF 109
Instructor: Jonathan Walpole
Instructor Office Hours - By Appointment
Teaching Assistant: Kendall Stewart
TA Office Hours - 12:00 to 1:50 pm in the Fishbowl (FAB 120)


This course is an exloration of operating systems concepts for graduate students. The course is based on research papers, and will involve extensive reading and assimilation of ideas. The reading list has been carefully selected from classical and recent research papers in order to introduce and develop a range of important concepts and developments in operating systems, and systems building in general.

In the first third of the course we review thread-based concurrent programming, studying its advantages and problems. We compare and contrast this style of system design with an event-based approach to system design, exploring arguments that one approach is better than the other, and vice versa, and that they are, in fact, duals of each other.

Our discussion expands to compare procedural vs message passing approaches to system design and looks in detail at the implementation of remote procedure call mechanisms that can support a procedural style of programming across protection domain and machine boundaries (i.e., above a message passing substrate). Again, this illustrates certain dualities among design approaches.

In the second third of the course, having studied a variety of system design alternatives and the implementation of some important underlying building blocks, we move on to compare and contrast various operating system kernel architectures, including monolithic kernels, based on strict top-down layered construction, layered kernels that use up-calls as well as down-calls, and various modular operating system designs. We study first generation micro-kernel operating systems that use hardware-based protection mechanisms, second-generation micro-kernels that use software-based protection strategies to offset some of the performance problems of early approaches, and highly optimized current-generation micro-kernels. We then compare these approaches with various other operating system architectures, including those based on virtualization and exo-kernels.

In the last third of the course we focus on one of the most important present day concerns for systems designers: how to design and implement scalable concurrent systems. We explore, in detail, the limitations of conventional approaches to synchronization, including the implementation of various locking approaches in the Linux kernel, the performance characteristics of spin-locks on shared memory multiprocessors, and the implications of hardware and compiler-level memory access reordering on the correctness and performance.

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 just to help students learn about different systems, but also to help them 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 related papers.

In addition to the considerable amount of conceptual work and literature review, the course will also involve a substantial, multi-part, 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, and in particular to introduce students, first hand, to the complexities of moving operating systems functionality to user-level: a trend that we will have seen extensive evidence of in the research papers.


If you have not taken, and passed with a grade B or better, an introductory course in operating systems this is probably not the course for you! It would be a good idea to take CS333 first. On the first day of class we will hold a short test to help you evaluate whether you have the necessary background knowledge to safely embark on CS533. If you do not, you will be encouraged to to take CS333 first, so that you can gain the necessary background before coming back to CS533 in a later term. If you go this route you should 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 and linked below in the Schedule & Syllabus section.


Your final grade will be calculated as follows: midterm exam - 50%; final exam - 50%;

Exam questions will cover material from the papers, lectures and programming projects.

Paper Reviews

Prior to each class, you must submit a written review of the reading materials listed for that class. Reviews should summarize the papers, capturing the key technical contributions and outlining the relationships with previous papers. The reviews should not be high level, broad-brush summaries, but should contain precise descriptions of the relevant technical details. A good rule of thumb to see if you are making an appropriate trade-off between level of detail vs abstraction, is to consider whether your reviews would be sufficient to allow you to use them to revise for exam questions about the material, rather than having to reread the full papers. When you listen to my lectures on the materials and consider the quiz questions at the end of each class, you should be able to tell whether your reviews are at the appropriate level or not. When reading scientific papers it is often useful to ask (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 our case, 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@pdx.edu with subject heading [CS533 Paper Review], prior to the start of class. 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. 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
I will hand out a test paper to help you to evaluate whether or not you are adequately prepared for taking CS533. The test will evaluate a broad range of Operating Systems concepts at the undergraduate level. If you find you do not have sufficent background knowledge, you should defer taking CS533 until after you have successfully completed CS333.

Class 2 and 3
Threads and Concurrency
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; Scheduler Activations
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; Kernel support for user-level cooperative threading on shared memory multiprocessors.

Class 7
Remote Procedure Calls (RPC)
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 and Hardware Reordering of Memory Accesses
Discussion of the correctness implications of compiler and architecture-level reordering when concurrency is implemented outside the compiler (i.e. through a thread-library). Memory consistency models of modern multiprocessors, sequential consistency, weak consistency models, memory barriers, and implications for performance and scalability.
Class 19
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.
Final Exam
Final Exam -- 1230-1420
In-class, closed-book exam. Start time 12:30 pm. End time 2:20 pm. Held in our usual classroom (Hoffman Hall 109).

Back to Jonathan Walpole's home page