CSE-506: Course Information (Fall 2016)

Course Objectives and Description

This course will be an in-depth study of important concepts and techniques found in modern computer operating systems. It will not attempt to provide a comprehensive introduction to operating systems. Some previous exposure to the basics of multi-programmed operating systems will be assumed. This will permit a detailed examination of some of the more important areas, including file systems, storage, virtual memory, networking, and security, with an eye to recent directions in these areas. Textbook readings will be supplemented where appropriate by papers from the research literature.

An important part of the course will be the case study of an actual operating system. We will primarily use Linux 4.x in this class. Students will study the source code for this operating system, and will do programming exercises and projects that involve modifying the operating system and measuring its behavior and performance.

If you follow the course readings and homeworks, you will come out of this course with a basic understanding of a modern operating system. You will be able to read major parts of source code for Linux and generally understand what they do. You will even be able to write simple kernel modules from scratch, or modify existing complex ones.

Prerequisites

  1. The officially published prerequisites for this class are CSE-306, the undergraduate level operating systems course. It is necessary. If you've taken an equivalent course elsewhere, and it includes actual programming experience in any Unix kernel, please speak to me first to get an approval to take this class. If you've never taken an introductory operating systems course before, you may not take this class; in some cases, having industry experience in the same field is enough.
  2. You should already know the C programming language and be proficient with it. You should know, for example, how to debug pointer problems and other memory "trashing" bugs that often come up in C programs. This course will not teach you C or basic debugging techniques (though we will discuss how to debug the Linux kernel).
  3. You should already have basic exposure to Unix commands. You should know what ssh, cc, gcc, make, ar, as, nm, ln, ld, cpp, vi/emacs, gdb, and other such commands do. We will not teach you how to use Unix (we'd like to spend the time teaching you about operating systems instead).
If you do not fulfill the above three requirements, you should consider very strongly taking CSE-306 instead of this course.

Other recommendations which would greatly help you in this class:

Who Can Take This Class

CS graduate-level courses are generally intended only for CS graduate students in a CSE degree program such as the MS or PhD programs!

If you do not fulfill the class prerequisites, you may not take this class without instructor permission.

Unfortunately, the university registration system does not always validate prerequisites or enforce registrations based on degree programs or department affiliations. Furthermore, we have limited resources available for this class: seating, teaching staff, and laboratory facilities. Therefore, at my discretion, I will collect information about each student who wants to take this class and correlate it with university records. Then I will decide who can take the class. Note that this is independent of whether you are already registered for the class or not. Priority will be given to CS graduate students.

In either case, I will endeavor to allow everyone who has the proper background to take this class, including undergraduate students and non-CS majors.

Finally, the lab resources of this class are limited and thus reserved only for registered students. No auditors are allowed in this class.

Examinations

There will be two exams in this course: a midterm exam, to be held in-class, and a final exam, which will be held during Finals Week at the officially scheduled date/time. See the course calendar for specific exam times and locations. Both exams will be closed book.

Textbooks

You can get a copy of the following book from Amazon, or read it online from within the Stony Brook campus, through the Safari online books:

Note: Be sure NOT to get the older editions of this book, which covered Linux 2.2 (1st ed.) and 2.4 (2nd ed.). We'll be using this third edition which covers Linux 2.6.

I expect to be covering some portion of the material in this book, and I will expect that people will read the relevant parts of them. I will not cover every chapter in detail or in order. I will supplement the book with online material, research papers, and other resources as needed.

The book is inexpensive and is available from the university book stores as well as Amazon and your neighborhood book store.

Other standard references typically used in operating system courses are:

If you need help with C/Unix, my recommendation is for these classic books: If you are interested in Networking internals of Linux, I recommend this:

If your previous exposure to operating systems principles is weak, you might wish to refer to these books.

Handouts and Other References

Besides the course text, during the semester we may study some research papers from industry and academia. We will also read parts of the source code of the Linux operating system. These references will be made available via the course home page, at the following URL:

http://www.cs.sunysb.edu/~cse506/

Homework

The homework in this course will consist of three types of activities:

  1. Reading from the textbook, assigned papers, and Linux source code. You obviously won't be graded on this part of the homework, but the exams will contain questions to try to determine whether you have done the reading and integrated the reading material into your own understanding of operating systems. Note also that you are resposible for reading all of the posts on the class mailing list. The list will be an invaluable informational resource for you throughout the class (that's why you must subscribe to it).

  2. Programming Exercises in which you will use operating system features, make modifications to a real operating system (Linux) to add new functionality, to change the behavior of the existing system in some way, or to instrument the system to make performance measurements.

  3. Class Project which will span the latter part of the semester. You can consider it a "large homework assignment."

Reading will take place on an ongoing basis throughout the semester. Programming assignments will be given regularly, with each assignment due three to four weeks after it is issued. There are 2-4 programming assignments, with the last assignment often being a larger project conducted in a team. I feel that actual programming experience is extremely important in the systems area, and so I have assigned a fairly high weight to the programming portion of the grade (see Grading below) to help motivate you. You must work on the programming assignments alone, unless otherwise specified.

For homework 1 you must work alone. For homework 2 you may work with one other student (i.e., a partner). For the class project you may work in a team of at most four students total. Larger partnerships will not be permitted.

You must turn the homeworks in on the day they are due and on the time they are due as listed in the course calendar. Since the homeworks will include programming exercises, students are urged to plan ahead to avoid congestion of the computer facilities at the last minute. If your code is incomplete or is not working by the due date, turn in whatever you have. Any homeworks that are submitted after the due date might or might not be graded, at the convenience of the course staff; if we grade them, we may elect to deduct a number of points for lateness, at our discretion. (Our typical policy is to deduct 2 points for every hour that the assignment is late, rounded up.) Late homeworks that are not graded will be held until the end of the semester, in which case I will have a look at them to decide whether you will be receiving a fair final grade. Generally speaking, if your homework assignment is not graded due to late submission, at my discretion you will receive either a zero for that assignment or you will receive a score equal to the average grade you received on all your homeworks that were graded. If some sort of emergency prevents you from submitting your homework on time, supplying me with suitable documentation might influence the choice I make, but please do not ask me to tell you that it is ``OK'' to submit your homework late. It is never ``OK'' to submit your homework late, but you will benefit more from submitting a late homework than if you submit nothing at all.

Academic Dishonesty

For the programming assignments, you will work alone. For the project, you may work with a partner. If you work alone, you submit your own work. If you work with a partner, you will submit your assignments jointly with your partner. Whether or not you work with a partner, you may discuss the programming assignments with anyone you like, but you may not share code with anyone other than your partner. The code you and your partner submit must be your own work, and only your own work. Any evidence that source code has been copied, shared, or transmitted in any way between non-partners (this includes using source code written by others in previous semesters, or by persons outside of the class or USB!) will be regarded as evidence of academic dishonesty. (BTW, there are some wonderful tools out there such as MOSS to compare N programing assignments and correlate those that have a shared code basis, even if the code had been changed significantly!)

Note: while I encourage you to seek out information on the Web, if you do use any Internet/Web sources in your assignments (including books and any other media format), then you must cite and acknowledge those sources properly. Not doing so constitutes academic plagiarism, and will not be tolerated.

I am very serious about not tolerating academic dishonesty. In a graduate class, when I am able to establish that academic dishonesty has occurred, I generally assign the student in question a grade of "F" for the course and forward the particulars to the Graduate Program Director (GPD) for inclusion in the student's folder; the GPD may decide to forward the student's case to the CS Department Graduate Grievance and Appeals Committee (G-GAC). If the student is a repeat offender, I ask that the Graduate Program Director initiate proceedings to dismiss the student from the degree program. For more information, see the Graduate Academic Dishonesty departmental procedures. Besides, we're here to learn. Do you want to get a good job and impress your peers with your programming skills, or get fired by your boss for failing to get the job (or worse, get sued for copying someone else's work).

For more information, see the Academic Judiciary Web site.

Grading

The final grade will be determined as follows: The raw scores obtained by all students on each assignment and exam will be standardized for that particular assignment or exam either (at my discretion) by converting them to percentile scores, or else by applying a linear transformation to map the scores to a standard [0, 100] scale. A weighted sum of the resulting standardized scores will then be formed (with weights as shown below) to obtain a composite score for each student. Finally, the composite scores will be ranked, and I will apply a subjective method of my choice to determine the cutoffs for each grade category. Absolute performance standards, the distribution of composite scores, information derived from late homeworks, and class participation are factors likely to contribute to this decision.

Generally speaking, to get at least a B+ in this class, your overall numeric grade in this class must be above 75% of the total possible number of points (not counting extra credit). Note that this does not mean that everyone who gets less than 75% will automatically get a grade less than B+.

PhD students taking this course as part of qualifier exams, take note. Historically, less than 20% of students who took this course got an A- grade or better. Pleas for an A- or better at the end of the semester will not be accepted.

To pass this course, you have to get at least 50% of the total numeric cumulative grade, not counting extra credit. Note that if you get less than 50%, it does not mean an automatic failing grade, but the grade will not be a good one either.

Attendance and participation in classes, in particular, will be factors that can offset borderline grades. This includes conversations with the instructor and TA over email, using the class mailing list, and so on. I also often take into account evidence of improvement over the course of a semester. However, I will not entertain end-of-term pleas to get a certain grade.

So that you can get an idea of how you are doing as the term progresses, I will report rough percentile information when I hand back each assignment. Final percentile scores will not be computed until after all grade changes and corrections have been taken into account at the end of the term.

The exams are closed book and include a mix of multiple-choice and programming questions. There is no negative grading or penalty if picking the wrong choice in a multiple-choice question.

Grading of Programming Assignments: To help you understand how your programming assignments are graded, we will post a detailed grading criteria for each assignment shortly after the assignment is handed out. This will help you focus your efforts based on what we plan to test and grade, as well as ensure equitable grading.

Re-grading: after each grade is given out, you will have a chance to discuss it with the grader and the instructor. You must first discuss your grade with the grader, within the first 48 hours after the grade has been handed back. It's highly recommended that you take some time to review your entire grade before discussing it with the grader. After discussing your grade with the grader, if you wish, you may discuss it with the instructor during office hours or by appointment.

Extra credit: In some instances I may assign extra questions or problems, designated as "extra credit." These will be optional additional points given to students based on extra credit work performed. Any extra credit points accrued by any student will be used as follows. The final course grade will be assigned as a letter grade which excludes all extra credit points. Then I will apply a subjective method to determine how much value to assign to extra credit points. Extra credit points can only be used to raise your final course letter grade. In other words, you are not obligated to do any of the extra credit work, and you can still get an A in this course.

Working alone on the HW2/HW3: Some of you may choose to work alone on assignments in which I permit teams; others may work in teams. To be fair to the people who work alone, I often will expect more substantial work accomplished when working in pairs. In addition, when assigning final course grades, I will often apply a subjective method to account for people who worked alone.

Special Assistance

The Provost has required that all faculty include the following statement in their syllabus handouts:
If you have a physical, psychological, medical or learning disability that may impact on your ability to carry out assigned course work, I would urge that you contact the staff in the Disabled Student Services office (DSS), Room 133 Humanities, 632-6748/TDD. DSS will review your concerns and determine, with you, what accommodations are necessary and appropriate. All information and documentation of disability is confidential.

Schedule of Topics

Covering a full modern OS in one such class is not possible in great detail. Therefore we will focus on three aspects of Linux: File Systems and Storage, Networking, and Security. Other topics will be covered, just not at the same level of detail.

The list of subjects covered may be adjusted based on the level of preparation of the students in the class. If nearly everybody has some prior OS course, then we can pursue more advanced topics at a more rapid rate. If not, then we have to go slower and do more basic things.

The list of topics I expect to cover in class (not in this order) are as follows:


Last Updated: 2016-09-18