CS
414, Introduction To Operating Systems
and
CS
415, Practicum in Operating Systems
Instructor:
Professor Kenneth P. Birman
4126A Upson Hall, 607-255-9199, email: ken@cs.cornell.edu
Office Hours: Tuesday and Thursday 9:00-10:00 (or by appt.)
415 instructor: Professor Raoul Bhoedjang
Ph.D TA information and office hours:
Rie Ando, kubotar@cs.cornell.edu,
490 Rhodes Hall, 5-8830. TR 11:30-12:30
Matthew
Harris, mharris@cs.cornell.edu, Upson 5152, 5-3495,
MF 1-2
Ioannis
Vetsikas, vetsikas@cs.cornell.edu,
Upson 5136, 5-9730, R 1:00-2:00, F 3:00-4:00
Fabio
Pellacini, fabio@cs.cornell.edu, 592
Rhodes Hall, 5-6705, M,T 2:00-3:00
MEng TA information:
Rui Wang (ruiwang@cs.cornell.edu),
Girish
Chander (girish@cs.cornell.edu)
David
Gutierrez (guti@cs.cornell.edu) Note:
David is primarily handling cs415
Newsgroups (for
day to day information):
news://newsstand.cit.cornell.edu/cornell.class.cs414
Homework
Assignments:
Homework 1
Homework 1 solution
Homework 2
Homework 2 solution
Homework 3
Homework
3 solution
Homework 4
Homework 4 solution
Homework 5
due November 30
Exam
Solutions:
Prelim1
Mean was 60, low 14, high 97
Prelim2
Mean was 78, low 40, high 100
Schedule for the Course, Assignment Due Dates, Exam Dates
CS 414: Introduction to Operating Systems
An operating
system is the layer of software that mediates between the application program and the
hardware on which it executes. It manages hardware resources and presents users with a
hospitable environment for program development and execution. To make effective use of any computer system, one
must understand the basic principles of operating systems. With the prevalence of
networked applications, which often must do several things at the same time, many of the
concurrency problems and virtual memory
techniques that only mattered to operating system designers have become issues for
application programmers, too. Understanding how the operating system exploits concurrency
while avoiding concurrency-related bugs and race conditions is critical to effective
development of this class of applications. Managing
limited resources intelligently can be a key to building applications that perform well in
networked environments. Thus, knowledge of
operating systems is central to fluency in modern computing environments.
The goal of CS414 is
to expose students to principles of concurrent programming and the design of operating
systems. Our study includes the layer of
software that manages a computer and its devices, as well as the utility programs that
manage the file system and facilitate development, debugging, execution and monitoring of
application programs. A special emphasis will
be placed on examples and issues associated with the use of PC's running modern operating
systems like Windows 95 and Windows/NT, and applications like Internet Explorer or
Netscape. As a result, each student will:
� Obtain a basic understanding of the structure of
the operating system,
�
Learn the principles underlying
the design of concurrent programs,
�
Understand how contemporary
operating systems manage virtual memory, file
systems, and network communication, and
�
Explore some of the issues
raised by the explosion of networked applications and the emergence of web browsers that
run languages like Java.
Although CS414 considers some case studies, the
course is primarily devoted to techniques, issues and insights that span a range of
systems. Thus, despite our interest in modern operating systems and languages, what you
learn in cs414 will be applicable to any system you might later encounter.
The topics covered in
CS414 include: concurrency and parallel programming, synchronization using semaphores and monitors, deadlock and livelock
(detection and avoidance), interrupts, processor priority mechanisms, segmented and paged
virtual memory management, multiprocessing, scheduling, file systems, protection and
security, message-based systems, web browsers and agent languages, windowing software and
environments, and distributed computing concepts.
CS 415: Practicum
in Operating Systems
CS414 students are
encouraged to enroll in CS415. CS415 gives
students some hands-on experience with the techniques covered in the course. The project
is in “stages”, with the first stage somewhat separated from the others. During Fall 1999, we’ll be working on NT
workstations using Java (Visual J 1.1 and the Microsoft Developer’s Studio) for our
work. This is a fairly easily learned system
with lots of debugging and programming support, and lots of example applications. Students who are familiar with UNIX may want to
use the Korn programming tools (they include things like “grep”), but VJ 1.1 is
self-contained, very well documented, and pretty easy to learn. Which is good, because we won’t be teaching
you the system in CS415: you are expected to pick it up on your own during the first few
weeks of the semester. (If you don’t
know Java, you’ll also need to teach yourself Java; the language is just like C with
a few extra features supporting object-oriented programming and multithreaded
concurrency).
The first stage
of the project will use Java threads to experiment with some of the concurrency control
techniques we’ll cover during the first lectures in CS414. You’ll get to implement and play with the
algorithms that we prove things about in class. However,
since many people will be learning Java, this stage of the project is very unambitious.
The remainder of the semester uses Java to develop
a larger system. . I’m not sure yet what
we’ll be doing this year, but I’m currently leaning towards a project we did
very successfully a few years ago. It
involved implementing a so-called network file system, with a client interface for doing
common file operations such as opening and reading or writing the file, and a server side
that implements the file system as a whole, using a single
large file to store all the files and directories that the user might see. You get to design the disk representation of the
file system, the caching and prefetching policies, and to instrument your solutions to
ensure that performance is as good as possible. Network
file systems are a big part of modern computing environments, so this experience should
give you a lot of insight into what real operating systems do and how they work.
Once Professor Bhoedjang arrives and settles in,
we’ll finalize the project plan and will make an announcement in class.
CS415 takes time, which is why we offer it as a
separate 2-credit course. The course meets once per week, on Monday at 3:35 in Thurston
205, but most of the time associated with it will be spent in front of PC's in our Intel
CSUG lab (Upson 313), coding your solutions and testing them.
Students who enroll in CS415 gain a direct exposure
to the sorts of core issues that arise when working with contemporary operating systems. This experience is relevant to many other
settings. Moreover, students who have had the
experience of building a moderately large software system in a structured, supervised
manner often find it much easier to structure other large software projects and to debug
large systems in a step-by-step manner later.
All of your work, in both CS414 and CS415, is
expected to be done individually. We
won’t have any programming “teams” this year, and although you are welcome
to talk to friends, your work must be your own. Sharing
of code is strictly forbidden.
CS414 Text: Silbershatz,
and Galvin: Operating Systems Concepts (5th Edition)
Prerequisites
CS414 requires some general knowledge of simple
programming techniques and data structures. Normally,
you get this in CS410, which is a pre-requisite or co-requisite to the course. It also requires a good understanding of computer
architecture at the level of CS314: assembler language, subroutine calls and argument
passing, registers, memory caches, virtual memory hardware, interrupts and processor
priority, kernel-user mode, DMA transfers, device interfaces. We won't cover this material and we will refer to
it.
Teaching Assistants
CS414 and 415 have 4
TA's this fall: Fabio Pellacini, Rie Ando,
Matthew Harris and Ioannis Vetsikas, as well as two additional MEng TA’s. We haven’t worked out the exact
responsibilities for the different TA’s yet but all of them will have office hours,
and we’ll provide details in a handout soon.
Prelims and Exams
There will be two in-class CS414 prelims and a final. Because the University scheduled the final very late (Dec. 16), we’ll have it in class on the last day of classes instead. The three exams count equally towards your grade. There will also be a few homework asssignments; homeworks count for between 15% and 25% of your grade (the exact curve won’t be decided until later in the semester). CS415 is graded entirely on the basis of the projects.