CSCI 3411, Fall 2011: Operating Systems

Professor: Gabriel Parmer
Office hours: Tuesday 2:30-3:30, Thursday 3-4, Philips 720E
gparmer at gwu
Class Schedule: Tuesday/Thursday 12:45-2:00pm, Tomp 201

Lab (required attendance): Thursday 2:10-3:45 or 6:10-8:00pm, Tompkins 211
TA: James Taylor (jrt at gwu), 313 Staughton
Office hours: Thursday 4-5, Friday 2-3

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 memory, file systems, networking (sockets and protocols), and distributed systems.

The workload for this class is heavy and programming intensive.

  • 8/29: First day of class. We so excited! Fun, fun, fun, fun! (Note, first class is not on Friday.)
  • 10/6: Midterm will be on 10/20.
  • 10/6: Final is on Tues, Dec 20th, 12:40-2:40
  • 10/25: Final project is posted.
  • 12/13: The practice homework is available.

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 design
  • experience both development and experimentation in a real OS
Structure - This class is broken into two main activities: lectures and lab.
  • Lectures will discuss the main concepts in systems with reference to implementation details where beneficial. A series of written homeworks and exams (midterm and final) test student's understanding of the lecture's concepts.
  • Labs will help you jump into the Linux 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

  • CS 135, 143
  • Assignments for this class will be done in C, and will require kernel-level programming. Though we do not assume that you have kernel experience, if you aren't somewhat comfortable with C, you will have a very difficult time. Thus, a familiarity with C or a willingness to quickly learn and practice it is required.
Responsibilities - Students must
  1. Attend all classes unless you are sick or there is an emergency.
  2. Interact, ask questions, and generally participate in class discussions.
  3. Attend all labs, and do work assigned therein.
  4. Complete programming problems assigned in lab, and all written assignments individually.
  5. Work productively as a group on an extended and difficult project.

Course Material

Required Text:

  • Operating Systems Concepts, 8th edition, by Silberschatz, Galvin, and Gagne
If you have trouble understanding the Linux source code, I recommend the following books:
  • 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. If you can't install it on your home computer and want to, contact me.

If you're having trouble with C, here is a list of references:

It is your responsibility to get up to speed in C, so please use these resources.

Once you are more advanced in C, it will be useful to read the style guide for Composite, our research OS here at GWU.


Events are in bold. Note that this schedule is subject to change.

8/30, 9/1 Introduction and OS fundamentals
  • Definitions, Computer Architecture, OS History, OS Structure

Chapter 1,2
9/6, 9/9 Processes, Inter-Process Communcation, Threads
  • Address spaces, I/O, Isolation, and Run-states
Chapter 3, 4
9/13, 9/15 CPU Scheduling and Synchronization
  • Scheduling Mechanisms, Algorithms, and Evaluation. Critical Sections and how they are provided
Chapter 5, 6, 19
9/20, 9/22, 9/27 Synchronization Cont. and Deadlock
  • Semaphores/Monitors, Deadlock conditions and Solutions
Chapter 6, 7
9/29 Memory Management
  • Allocation Algorithms
Chapter 8
10/4, 10/6, 10 Paging and Virtual Memory
  • Segmentation, Address Translation, Demand Paging, Page Replacement Algorithms, Thrashing
Chapter 9
10/20 Midterm N/A
10/25, 10/27 File-Systems and Storage I/O
  • File-System API, Rotating Storage, File-System Layout, Block Device Scheduling
Chapter 10, 11, 12, 13
11/1, 11/3 The Networking Stack
  • IP, UDP/TCP, Socket API, Device Drivers, DMA
Chapter 16
11/8, 11/10, 11/15 Distributed Coordination
  • Consistency/Event Ordering, Synchronization, Election Algorithms
Chapter 18
11/17, 11/22 Spare Days
11/23-11/27 Thanksgiving Break N/A
11/29 Protection and Security
  • Fault tolerance, Access control, Security policies
Chapter 14
12/1 Course Reflection N/A
12/6 ??? Chapter
12/8 ??? Chapter
??? Final Exam N/A


  • 8/30 - Class Introduction, OS definition and history [pdf]
  • 9/1, 9/6 - System Architecture and Structure [pdf]
  • 9/8 - Structure and Processes [pdf]
  • 9/15 - 9/19 - Threads and Communication [pdf]
  • 9/20 - 9/12 - Scheduling I [pdf]
  • 9/27 - Real-Time Scheduling [pdf]
  • 9/29 - 10/11 Synchronization [pdf]
  • 10/13 - 10/18 Deadlocks [pdf]
  • Memory Management I [pdf]
  • Memory Management II[pdf]
  • Virtual Memory [pdf]
  • Virtual Memory II [pdf]
  • File System API[pdf]
  • File System Implementation [pdf]
  • I/O Scheduling [pdf]
  • Protection [pdf]
  • Summary [pdf]


Grades will be assigned with the following proportions:

Homeworks and Quizes: 50%
Midterm: 20%
Final: 20%
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%).

Late Policy:

  • 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.

Academic Honesty

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.
Academic Integrity Policy
Credit: I'd like to thank Prof. Narahari for the first versions of this academic honesty policy.

Additional Material

If you're interested in Composite, the OS we are developing 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.

Websites geared toward systems topics (or that have subsections on systems):

  • Linux Weekly News: Free content is that which is at least a week old (see the Archives).
  • Two brilliant classes on microkernel construction.
  • Arstechnica: geek news, often with a high-level overview of systems/architectural topics.
  • OKLabs videos. A microkernel company. Specifically, see the series titled, "Advanced OS with Gernot Heiser".
  • OSDev Wiki: the resource on practical OS construction and hardware manipulation.
  • 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 hacking! Hackaday!

Blogs and articles (remember that these are not authoritative sources!):

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!
  • Daikon: Because who doesn't want to use machine learning to infer their own program's behavior?
  • More powerful link-time optimization!
  • A great C library for simple machine learning operations such as classification.