This course covers the fundamental concepts of operating systems,
focusing on resource management and abstraction. This includes OS
structure, processes and thread management, communication with
peripherals (I/O), synchronization, deadlocks, memory management,
Virtual Machines, cloud infrastructures, and abstractions for cloud
The workload for this class is heavy and programming intensive.
- First day of class TODO list:
- Sign up for the
- Complete the first assignment (make a github account, use
git, perhaps install Linux in a VM).
- Do you remember/know C?
Spend a few minutes writing a
linked list that supports:
void add(struct linked_list *ll, void
int length(struct linked_list *ll),
void *remove_first(struct linked_list *ll), and
contains(struct linked_list *ll, void *value).
If you have any problems with this, you need to take
action now. See the Essential C pdfs in
the Course Material section below (esp. the practice
If you don't become comfortable with C soon, you will not do
well in this class. You will profit later from having a
firm grasp on C!
- If you aren't running Linux, consider installing VMWare
player or Virtual Box on your personal machine. We will use
gcc, binutils, git and other programs that are typically found
in Linux. Importantly, we will be testing everything in Linux
(Ubuntu 14.04), so you'll likely want to test in that.
- Gear up for a challenging, but satisfying semester! Get
ready to demystify how computers work!
- All subsequent news will be posted on Piazza!
Please click on any section below to see its contents.
Objectives and Structure
Objectives - In completing this class, students will...
- understand key concepts involving system resource management,
organization, and abstraction
- understand how an OS manages and interfaces with hardware
- understand fundamental trade-offs integral to system
- experience both development and experimentation in a real
Structure - This class is broken into two main activities: lectures
- Lectures will discuss the main concepts in systems with
reference to implementation details where beneficial. A series of
homeworks (all in C) will test student's ability to apply the
courses concepts in a set of projects. The midterm and final exams
test student's understanding of the lecture's concepts.
- Labs will help you jump into the xv6 kernel and learn how to
write and understand code in key subsystems. You will have
programming assignments related to lab lectures throughout the
semester. In the second half of the class, you will have a large
group project involving kernel programming.
Course Prerequisites and Student Responsibilities
Responsibilities - Students must
- Attend all classes unless you are sick or there is an emergency
in which cases you must contact the professor via
email before class.
- Interact, ask questions, and generally participate in class discussions.
- Attend all labs, and do work assigned therein.
- Complete programming problems assigned in lab, and all written
- Work productively as a group on an extended and difficult project.
- Operating Systems Concepts, 9th edition, by
Silberschatz, Galvin, and Gagne. If you have another edition, it
is probably OK.
If you have trouble understanding the xv6 source code, I recommend
the following resources:
You can fork the xv6 source
on github. When
you do, test that you can run it with make, and make
In the end, you have to get comfortable walking through the
code. Using a code indexing system will make this
easier. ggtags for emacs does great, but there are
corresponding technologies for nearly all editors.
If you're having trouble with C, here is a list of references:
It is your responsibility
to quickly get up to speed in C,
so please use these resources.
Events are in bold. Note that this schedule is subject
|Topic||Reading "xv6 book (silberschatz)"|
Introduction and OS fundamentals
- Definitions, Computer Architecture, OS History, OS Structure
|Chapter 0, 1, 3 (Chapter 1,2), and this post|
Processes, Inter-Process Communcation, Threads
- Address spaces, I/O, Isolation, and Run-states
|(Chapter 3, 4) and this post|
CPU Scheduling and Synchronization
- Scheduling Mechanisms, Algorithms, and Evaluation. Critical
Sections and how they are provided
|Chapters 5, 4 (Chapter 5, 6, 19)|
Synchronization Cont. and Deadlock
- Semaphores/Monitors, Deadlock conditions and Solutions
|(Chapter 6, 7)|
Memory Management and Protection
- Segmentation, Paging, TLBs, Address Translation, Demand Paging
|Chapter 2 (Chapter 9)|
File-Systems and Storage I/O
- File-System API, Rotating Storage, File-System Layout, Block Device Scheduling
|Chapter 6 (Chapter 10, 11, 12, 13)|
- Page Replacement Algorithms, Thrashing
Note that these will be posted on Piazza, and questions can be
- Class Introduction, OS definition and history
- System structure and protection
- System structure and processes
- IPC and threads
- Real-Time Scheduling
- Memory Management
- Memory Management II
- File Systems APIs and Abstractions
- File Systems Design and Implementation
Grades will be assigned with the following proportions:
Homeworks and Quizes: 50%
Class and Lab Participation: 10%
Homeworks include smaller programming assignment, written
responses, and a long final programming project.
Participation will be graded not only on attendance (50%), but also
on interactivity and involvement (50%).
If needs be, there will be short quizzes at the beginning of
- 66% credit: up to 24 hours late
- 33% credit: up to 48 hours late
- 0% credit: later than that
Because homeworks are every week, or every other week, it is too
harmful to get behind on them. Thus the late policy is quite strict
to discourage procrastination.
Just as you can do a google search for code online, it is
trivial for us to do the same. We have caught numerous people
cheating in the past in this way. If you feel pressured about an
assignment, please come see me instead of cheating.
You are not allowed to collaborate on the homeworks and the lab
assignments. The group projects require collaboration amidst each
group, but no collaboration between teams is permitted. Please refer
to the academic integrity policy linked from the course web page.
This policy will be strictly enforced. If you're having significant
trouble with an assignment, please contact me.
If you have not signed the academic integrity statement for homework
0, you will not receive a passing grade for the class.
If you're interested
the OS we
here at GW, don't hesitate to contact me.
In addition to the contents of the class, what follows is a list
of resources that will allow you to go beyond what you've learned.
This material is not mandatory for the class and is meant to give
you a springboard if you wish to pursue the ideas further. Many of
these are blog posts or articles for easy reading. However, because
of the informal format, please take the contents with a grain of
salt. I can point you to more thorough content if you want it.
If you find an website/article/tool that you think is worthy of
being in this list, let me know.
If you're interested in delving into Linux kernel programming, see:
- Linux Kernel Development by Robert Love
- Professional Linux Kernel Architecture by Wolfgang Mauerer
(free pdf should be available)
For kernel development, we will be using VMWare.
Websites geared toward systems topics (or that have subsections
- Linux Weekly News:
Free content is that which is at least a week old (see the
- Two brilliant
on microkernel construction.
- Arstechnica: geek news, often
with a high-level overview of systems/architectural topics.
videos. A microkernel company. Specifically, see the series
titled, "Advanced OS with Gernot Heiser".
- OSDev Wiki:
the resource on practical OS construction and hardware
- Agner's blog:
What's happening in those processors of ours? See more
architecture discussions at real world tech.
- From low-level embedded system hacking, to robotics, to
Blogs and articles (remember that these are not authoritative sources!):
- On binaries and understanding process layout: A
Whirlwind Tutorial on Creating Really Teensy ELF Executables for
Linux, and playing
- On memory
look at how malloc works on the Mac, and memory allocation
- On transactional memory (a synchronization mechanism):A
(brief) retrospective on transactional memory
- Concurrency via events or threads? Why
And how do you provide
- A great email
about efficient IPC implementation.
- What every programmer should know about memory.
Seriously. He's not kidding. Read this. And look at the
- Like file systems? Get some history.
- Higher-level description of a modern filesystem, ZFS
- On the hardware manipulations necessary to boot an OS: Roll your own
toy UNIX-clone OS.
- A simple UNIX clone: xv6.
- Correct use of virtual memory: You're Doing
- Intricacies of
...and you thought C was simple.
- How do they build the large-scale distributed systems at
- A history of networking physical level
and a great history
- Interface design is difficult. Where did UNIX get it wrong? Must read for
anyone thinking about designing an interface.
- On the
Brokenness of File Locking, or
interface design matters".
- A great resource
- Browsers don't do magic either! They are just
very, very, very
- Why low-level
programming matters even if you don't plan on doing it in
- Premature optimization may be
the root of
all evil. But
how to do it is essential.
- Coding style matters. Read how others have decided on a
- Reasonable lists
publications that have defined computing as we know it.
Really. cool. tools:
- DynamoRIO: Because it rocks
to modify a program as it's executing.
- SQLite: a small, well written,
data-base. Use it, read it, and be merry.
- Lua: a tiny language with a
runtime of about 10K LOC. If you want to know what a language
does under the wraps, here's a good place to find out (just
ignore some of the syntax oddities).
- Valgrind: Ever wonder what
your program's been doing in its spare time? This will tell you.
Required for debugging large C/C++ programs.
- LLVM: A beautiful compiler
backend. If you want to write a language, this will make your
life so much easier.
- FUSE: Want to write a
file-system, but aren't sure about all of that kernel
programming? And what if you need to use high-level libraries?
No problem; do it is user-space!
Because who doesn't want to use machine learning to infer their
own program's behavior?
- More powerful link-time
- A great C library for simple machine learning operations such