Course Information

Be sure to read all of this page!


Description

The purpose of this course is to explore the many problems and concepts involved in designing an operating system. We will begin with a simple question: "What is an operating system?" When we discover that the answer is a moving target, we will begin to discover what kinds of problems must be solved to present a user or programmer with a simple, virtual machine that may actually be running on top of disparate hardware.

There are two main questions surrounding the design of an operating system kernel (the core of any OS):

  1. How can a single program (the kernel itself) be structured such that an arbitrary number of other programs can run on top of it?
  2. How can the kernel manage the shared hardware resources so as to provide high performance, high utilization, low overhead, and fairness?

We will address the topics implied by these questions, and discover that some have good solutions, some have good but impractical solutions, and some have no good solution at all. The most critical topics will likely be the following, given roughly in the order that will we cover them:

We are not likely to delve far into the last two list items. For the other topics, we will cover the kernel structuring and resource management issues in as much depth as time allows, both through lectures and projects. By the end of the course, I hope that you will have a much greater understanding not only of how kernels work, but also policies for resource management are designed and analyzed.


Class times and materials

We will meet three times per week for a 50 minutes each. The meetings are at MWF at 10 am in SMudd 205. Note that at some point in the semester, we will be begin to use some of this class time as lab time, where time will be spent on the assignments, described below.

You are responsible for the material presented in every lecture. There is no attendance policy, but I strongly recommend that you attend all lectures. If you miss one, it is your responsibility to obtain the material that you missed.

The text for this course is Modern Operating Systems, 2nd edition, by Andrew Tanenbaum. The book will be available at the Jeffery Amherst College Store (although I ordered it a bit late, so call before you go there). Note that this text is recommended, but not required! The book can be used as a reference and as a reinforcement of material covered during lectures. However, since I will not be assigning readings or problems from it, I don't require that you have it.


Assignments

At heart, this will be a project class. Specifically, you will be implementing a basic operating system kernel on top of a simulated machine (based upon a contrived instruction set architecture). This virtual machine won't be all that interesting -- simple computations and basic text I/O will likely be all that we do with it. However, that should be enough for us to build an operating system and run some programs.

There will be four major projets, each one building on the next. Note that some of the projects will be divided into mini-projects. These projects will be done in teams (probably two people, perhaps three to a team). Each project requires some substantial design, programming, and debugging, so you should expect to spend significant time working on them. Initially, you will be given a very simple kernel that can boot and then support a single process running in a single address space. Then, during the course of the projects, you will make your kernel support:

  1. Multiple processes in a single address space
  2. Processes in independant, paged, virtual address spaces
  3. Processes that can communicate through message passing and signals
  4. Processes that can access a filesystem

While the topics covered by the project address only the core services provided by a common operating system, they are still the most important and, in some cases, present the most complex resource management problems. It is in doing these projects that we are likely to learn the most about both the structure of kernels and the algorithmic and resource management issues that any system must handle.

Warning: These projects will be programmed in C++. We will spend a little time in class, when needed, talking about the language. There will be handouts on details that you need to know, compiler use, and debugger use. There will be a preliminary assignment to help you get familiar with C++, the g++ compiler, and the gdb source-level debugger. I am always happy to answer questions that arise from language-based confusion. However, we will not be spending substantial class time on the language itself. I largely expect that you will pick up C++ as you use it. It is the language most like Java that compiles directly to a native executable format, and is most similar to the C in which most real kernels are now written.

There will also be occassional written assignments on material that is to complex to be covered by the projects. These assignments will address some of the more abstract concepts that arise in kernel design and implementation.


Exams

There will be a single oral, final examination for this course. An oral exam is unusual, but the OS material is well suited towards and interactive presentation. For this final exam, you will be responsible not only for material covered in lectures, but also for knowing and understanding all of your group's project solutions. Your examination will be individually scheduled when the end of the semester approaches.


Grading

Your grade for this course will be calculated based on the following forumla:

It is critical to ask questions and be involved in the details of this class. As you will find in doing the projects, the concepts don't sound too difficult until you get into the details of the solutions.


Late submission

A project not submitted by its deadline will receive a failing grade.

If you need an extension, you must submit a written request for that extension at least 72 hours before the deadline. Exceptions will be made on a case by case basis for illness and emergency situations.

These projects are involved, and you should plan to leave as much time for debugging as you needed to program the first version of your solution. Projects build substantially on one another, so it is important that your solution to a project be sufficient so that you may move on the next one.


Your responsibilities and my availability

I hope that this page has made clear the structure and intent of the course, and well as the expected workload and your responsibilities. By presenting this information at the onset, I hope to avoid using our valuable time on misunderstandings and negotiations. This course clearly imposes a substantial workload, and it will be critical that you not fall behind.

I will be available to meet with you about the material, projects, exams, lectures, or any other aspect of the course. Simply email me and we will set a time to meet as soon as possible. You can also try to find me in my office (SMudd 406) or the (new!) Faculty Research Lab (SMudd 015).


Scott F. Kaplan
Last modified: Thu Aug 28 10:47:42 EDT 2003