Operating systems provide an interface between applications and the underlying hardware as well as services to users. They are used on most modern platforms today - ranging from high-end supercomputers to embedded systems. The goal of this course is to describe and explore the fundamental architectural and algorithmic concepts involved in the design and implementation of modern operating systems. In many ways, this course draws concepts and ideas from every class you've taken thus far in the undergraduate CS curriculum such as data structures, algorithms, and of course computer architecture. More specifically, this course introduces the principles of operating system design. We will introduce OS concepts and then focus on the following core design principles of modern operating systems including: processes, inter-process communication and concurrent programming, scheduling, memory management, file systems, device management, and finally touch on the OS impact of recent multi-core and emerging architectures.
Aside from specific subject domain knowledge (listed below) a primary objective for this course is learning how to think about complex systems and their dynamics. This means representing those systems and reasoning about their behavior. This is not a matter of just learning specific facts or skills. This is a matter of learning how to think critically.
Of course we will focus on subjects specific to operating systems, so you will be gaining explicit knowledge about some of the topics within this domain. Upon completion of this course you should be knowledgable in the following areas:
Note:
Readings should be done before lecture (except first week). This schedule is tentative and may change as the
course develops. This schedule follows the textbook closely so that, in
general, you should always know where we are in the reading by the week number.
Additional readings may be assigned as needed.
I will ensure those are posted and known at least a week in advance of
the discussion.
|
Week |
Topic |
Text Reading &
Resources |
|
0 |
Introduction
to Operating Systems |
|
|
1 |
OS
structure, kernel space vs. user space |
Chapters
1 - 2 |
|
2 |
Processes,
threads, and concurrency |
Chapters
3 - 4 |
|
3 |
Multi-programming,
multithreaded, synchronization |
Chapters
5 - 6 |
|
4 |
Scheduling |
Chapter
7 |
|
5 |
Scheduling (continued) and mid-term review |
Chapter
7 |
|
6 |
Intro
to Memory Management |
Chapter
8 |
|
7 |
Caching,
Virtual Memory |
Chapter
9 |
|
8 |
File
systems |
Chapter
11 |
|
9 |
Storage
Devices, Files, and Directories |
Chapters
12 - 13 |
|
10 |
Beyond
Traditional Operating Systems |
Reading
to be assigned |
|
11 |
Final Exam |
The
following course policies will be observed this quarter.
Grading is based on the final number of points that you have at the end of the quarter. Each assignment/project/exam carries some number of points (below) that are added up at the end of the quarter. The final number of points you end up with will be divided by this total to determine your percentage of total. That percentage will be translated into a final decimal point (4.0 max) grade.
There
will be two exams - a mid-term (100 points) and final covering major conceptual
areas of the course (200 points).
There will be several projects during this course to familiarize you with the composition of modern operating systems and how to work with an OS. To ensure you’ve had some experience working with a real OS, we will be using Linux for several of our projects. You will learn how to build, modify, and test the proper operation of the Linux kernel. The details of these projects will be posted to the Moodle page for this class shortly.
I
will give make-up exams only with prior permission or written excuse.
Any attempt to receive credit for work that is not your own is plagiarism. Attempts to hide the lack of contribution for a weak team member will be counted as academic dishonesty.
You should feel comfortable discussing topics, including general approaches to assignments, in a collaborative atmosphere. Discussing concepts and methods to be applied to problems is often a tremendous aid to studying. But when it is time to sit down and write down answers or program code, you should work on your own (team's).
Although I expect most of this course to consist of lectures on the topics at hand, I much prefer to discuss the topics as a class. Some of the best classes I've led have been with well-informed, prepared students who come prepared with questions and ready to discuss the trade-offs involved with alternative approaches. While most modern operating systems follow general design guidelines, there are often times when deviation from general principles leads to better performance, accessibility, or user experience. However, to make such trade-offs one must understand what is being compromised.
I like to ask a lot of questions to generate discussion based on the material in the book and supplemental readings!! Please read these in advance of class and be prepared to discuss. Please feel free to ask questions and remember the only dumb question is the one that is not asked.
If you do miss a class you will need to make arrangements with classmates to obtain notes. I will not provide an 'extra' lecture for those situations.
You should already be subscribed to the mailing list, so please check your email regularly for course announcements and other mail from me or other students. You can check the archive in case you've missed an email.
See:
Disability
Support Services.