CS533 - Concepts of Operating Systems
Winter 2006

When: Tue/Thu 1800-1920
Where: 1031 CAPITAL Center
Instructor: Jonathan Walpole
Instructor Office Hours - By Appointment

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


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; support for application-specific virtual memory management; virtualization; specialization; operating system support for fine-grain timing; file system designs for performance and reliability; and general advice for system designers.

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.


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.

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. If you need to catch up on background reading about the basic concepts of Operating Systems I recommend "Modern Operating Systems, 2nd edition," by Andrew S. Tannenbaum.


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

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.


Each class session will be structured as two paper presentations made by students, followed by a discussion session, led by me, to integrate and evaluate the key concepts. You will be assigned at least one paper to present in class during the quarter. Preliminary assignments are listed below each paper. Presentations should be targeted to last 20 minutes and should emphasise the key ideas of the paper. Don't waste your presentation time on mundane details. You must extract the important contributions and present them clearly. 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 presentation early!

Position Papers

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

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. All students should subscribe to this list. Go to the following web page and follow the instructions:


Schedule & Syllabus
Class 1
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 completed CS333.

Reading: Slides: [ppt]
Class 2
Threads and Concurrency
The thread concept; concurrency and the need for synchronization; complexity of concurrent programming; steps toward automatic detection of race conditions.

Reading: Useful Links:
  • A tutorial on Pthreads (POSIX Threads) programming from LLNL.
Class 3
Classic Approaches to Synchronization
Classic papers on structuring concurrent operating system code; high-level abstractions for synchronization; implications of various implementation choices.

Reading: Discussion slides: [.ppt]

Class 4
Synchronization on Modern SMMPs
Implementing scalable synchronization in modern shared memory multiprocessors; Read-Copy-Update and its use in the Linux kernel.

Class 5
Event-Based Systems
The case against thread-based programming; the reactive programming model; event-based programming; performance and load management implications of threads vs events.

Reading: Discussion slides: [.ppt]

Class 6
The Duality of Threads and Events
The duality of event-based systems and thread-based systems; the case against event-based programming.

Reading: Discussion slides: [.ppt]

Class 7
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; kernel support for user-level cooperative threading on shared memory multiprocessors.

Reading: Discussion slides: [.ppt]

Class 8
Remote Procedure Call
Design and implementation issues for remote procedure calls (RPC); optimization of RCP for cross-address-space local communication.

Reading: Discussion slides: [.ppt]

Class 9
RPC Optimizations for Shared Memory Multiprocessors
How to implement RPC efficiently on a shared memory multiprocessor among user-level threads in different address spaces.

Reading: Discussion slides: [.ppt]
Class 10
Midterm Exam
In class written exam.
Class 11
System Structuring Using Layers
The advantages and disadvantages of layering as a kernel structuring approach.

Reading: Discussion slides: [.ppt]
Class 12
Extensibility via Hardware-Based Protection
Structuring operating systems as collections of user-level processes that communicate by local or remote message passing; emulation of legacy operating systems in servers above a micro-kernel; performance implications of micro-kernels.

  • "The Mach System" appears in "Operating Systems Concepts, Sixth Edition" by Abraham Silberschatz, Peter Baer Galvin, and Greg Gagne, published by J Wiley, 2002.
    Presenter: Agnimitra Roy
    Slides: [.ppt]

  • "Improving IPC by Kernel Design" by J. Liedtke, Proceedings of the 14th ACM Symposium on Operating Systems Principles, Ashville, North Carolina, December 1993.
    Presenter: Eric Hanson
    Slides: [.ppt]
  • Skim the following paper.

  • "The Performance of Micro-Kernel- Based Systems" by H. Haertig, M. Hohmuth, J. Liedtke, S. Schoenberg, J. Wolter, Proceedings of the 16th Symposium on Operating Systems Principles, October 1997, pp. 66-77.
Discussion slides: [.ppt]
Class 13
Extensibility via Software-Based Protection
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.

Reading: Discussion slides: [.ppt]
Class 14
Extensible Virtual Memory Management
Memory management on modern processor architectures; copy-on-write and copy-on-reference memory management; memory mapped files; using virtual memory to optimize IPC; extensible page fault handing via external pagers; applications of user-level virtual memory fault-handling;

Reading: Discussion slides: [.ppt]
Class 15
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)

Reading: Discussion slides: [.ppt]
Class 16
Exo-Kernel and Specialization
Exo-kernel concept; minimal operating system functionality; separation of mechanism and policy; techniques for implementing application specific handlers; dynamic specialization of packet filters; tool-assisted specialization of operating system code; reducing the software engineering overhead of building and maintaining high performance operating systems.

Reading: Discussion slides: [.ppt]
Class 17
Support for Fine Grain Timing
Fine-grain timer implementation; hard, soft and firm timers; real-time issues in general purpose operating systems; fine-grain preemptibility;

Reading: Discussion slides: [.ppt]
Class 18
File System Performance
Evolution of approaches to improve file system performance; the read-optimized Unix Fast File System (FFS); write-optimized Log-structured file systems.

Reading: Discussion slides: [.ppt]
Class 19
File System Reliability
RAID-based file systems; tuning reliability and performance; versioning.

  • "The HP AutoRAID Hierarchical Storage System" by J. Wilkes, R. Golding, C. Staelin, and T. Sullivan, in ACM Transactions on Computer Systems (TOCS), Volume 14 , Issue 1, Special issue on operating system principles, pages 108 - 136, February 1996.
    Presenter: Joe Rosinski
    Slides: [.ppt]

  • "Deciding When to Forget in the Elephant File System." D. S. Santry, M. J. Feeley, N. C. Hutchinson, A. C. Veitch, R. W. Carton, and J. Or, In Proceedings of the Seventeenth ACM Symposium on Operating Systems Principles, December 12-15, 1999, Charleston, SC, pp. 110-123.
    Presenter: Jon LeVitre
    Slides: [.ppt]
Discussion slides: [.ppt]
Class 20
General Lessons and Advice
Hints and rules of thumb for operating system designers; end to end arguments in system design.

Reading: Discussion slides: [.ppt]

Position paper due today!

Back to Jonathan Walpole's home page