More detailed information can be found here, including: time and place, purpose, prerequisites, books, grading, cheating, and computer systems and labs.
Here is the list of topics covered in this course. They will be mapped to chapters from the text as the course progresses.
You might check out the assignment timeline to help you plan for exams, papers and projects.
Slides from the in-class lectures will be available shortly after they are presented, depending upon how things go:
Also, I gave some tips on "How to Give a Talk" that you might find useful for paper and project presentations:
New! Check out the project presentation schedule.
The programming project will be an implementation project in that you will write code to explore, measure or enhance some operating system feature. There is great latitude in the focus of the project.
You will work in a group of two for the project. I'd prefer to limit the groups to only 2, but groups of three are also possible. If you really want a group with a different number of students, come talk to me. Working in groups will give you valuable "real-world" experience as well as provide you with a "built-in" source for help.
Projects must be ok'ed by the instructor before hand. You will submit a project proposal in the first couple weeks of the course. The project proposal should specify:
The main product of your project is a writeup. Your writeup includes all of steps 1-5 above. In addition, your writeup should have:
Include figures wherever appropriate. Keep in mind that the clearer your writeup, the clearer my understanding of what you did and the better your grade.
If appropriate, I encourage you to demo your project to me. Especially if you feel showing me your system, interface or experiments in action will help me understand your project (and your grade).
Part of your project grade will include an in-class presentation. Presentations will be a short summary of the problem, your approach and conclusions.
You are strongly encouraged to think of your own programming projects. However, if you are stuck or just want to see a sample project idea, check out this list of possible projects.
Students will be expected to select and present an OS research paper. Papers can be presented in groups of 2-3. You'll have the paper approved by me in the first couple weeks of the course. Presentations will be scheduled according to their relation to the course material. Presentations will be roughly 1/2 long, including discussion time. Part of the presentation will include submitting 2-3 questions that are appropriate for a final exam question on your paper.
You are encouraged to seek out papers for presentations on your own. You may select any article you like from any journal, magazine, or other source you think is suitable. This includes articles that are available on the web. Url's that point to entire sites, topics, news groups, or companies are not suitable (just url's to specific articles). However, if you are unable to find an appropriate paper you may select from this list of possible papers.
Here is the current paper presentation schedule.
Here are any code samples discusses in class, practice exams or any other demonstration-type class materials:
Here is a topic outline for the mid-semester exam. You might also check out the practice exam (with solution).
Here are the code samples for the simple operating system we have been looking at:
system.h - the
system header file used by all the simple OS samples.
create-proc.c - a
code sample of a process creation routine.
dispatcher.c - a
code sample of a dispatcher.
timer.c - a
code sample of a timer interrupt function.
error.c - a
code sample of an error interrupt function.
sys-interrupt.c -
a code sample of a system interrupt function.
system-parallel.h - modifications to the system header file to allow for a two-processor OS.
use-proc-table.c - modifications to the SelectProcessToRun() function to allow
for a two-processor OS.
Here are some samples showing the use of software signals:
signal.c
-- simple use of a Unix signal handler.
signal2.c
-- another simple use of a Unix signal handler.
signal3.c
-- still another simple use of a Unix signal handler.
signal-usr.c
-- using user-defined signals
signal-alarm.c
-- using signal to catch alarms.
signal-child.c
-- using signal for parent-child communication.
Here is a simple "Up Yours" client-server example that shows the use of pthreads. They use some wrappers to make sockets easier:
server.c
-- the "Up Yours" server.
client.c
-- the "Up Yours" client.
server.h
-- the common header file.
sock.c
-- the socket wrapper code.
sock.h
-- the socket wrapper header file.
Makefile
-- the Makefile to build the client and server.
Demos that have separate add and subtract threads that access a global variable:
add1.c
-- add and subtract to an unprotected variable.
add2.c
-- add and subtract to an variable protected by a mutex.
Makefile
-- the Makefile to build the add programs.
Other code samples:
micro-shell.c - a
very simple Unix shell written in C.
![[Return to the WPI Homepage]](http://www.cs.wpi.edu/images/seal.gif){kind=small}
![[Return to the CS Homepage]](http://www.cs.wpi.edu/images/new_cs.gif){kind=small}
![[Return to Mark Claypool's Homepage]](http://www.cs.wpi.edu/~claypool/gif/mark_thumb.gif){kind=small}