Advanced OS Final project guidelines
The final lab assignment for the class is to undertake a mini research
project of your choice in a group of 1-3 people. You may wish to
implement one or more of the features suggested as challenge problems
in the lab assignments. You can also implement any of the ideas from
papers we read in class, or anything else you think might be
interesting. At the end of the semester, you will turn in a paper
describing and evaluating your project, and present your work to the
Your project should be guided by the following deadlines:
- By Friday, November 11 you should form a
project team of 1-3 people (preferably 2) and email the course staff
to let us know with whom you will be working.
- Before Tuesday, November 15 you should
schedule a meeting of your team with me (David Mazières) to
discuss your proposed project. Once I have approved your proposal,
send the course staff a short (1 paragraph) description of what you
want to do, which we will post on the web site so everybody knows what
the different projects are.
Please schedule your meeting sooner rather than later, in case your
team needs to iterate on the proposal. Note, in particular, that it's
fine to meet with me if you don't have a concrete plan yet, as I can
suggest some things for you to look into.
Note: If you want to combine your project with your research or with
work for another class, this is in general fine, but please let me
know at the time of the proposal.
- By December 15 you must email the course
staff a paper describing and evaluating your project. The paper
should be no more than 10 pages in at least 11-point font. We will
post your papers on the class web site.
- At 12:15pm Friday, December 16, you will
present your project to the class and demo what you have done. Your
combined talk and demo should take no more than 20 minutes. You must
also submit the source code to your project at this time. Note that
this is a hard deadline, since we have to reserve a room for
the presentations and I have to submit grades for people.
Here are some ideas you might be interested in for projects. This
list is by no means exhaustive.
Note, that if you want to run JOS on real hardware for your project
(for instance for a performance evaluation), we have a limited amount
of lab space and equipment you can use.
Implement BVT or another interesting scheduling algorithm on JOS.
Modify bochs to add support for a hardware feature you think would
benefit operating systems, and then change JOS to take advantage of
this. As an example, you can look at Mondrix
which adds fine-grained memory protection. (Perhaps you could just
enhance JOS to take advantage of the Mondrian memory protection used
Implement a real file system for JOS.
Implement a single-level store like KeyKOS or L4, so that you
can power-cycle your machine and then resume executing processes.
Implement a highly-optimized threads package for JOS.
Implement a novel protection model for JOS. (E.g., hierarchical user
IDs, so any user can create "sub-users", or military-style mandatory
Implement a network stack, and some "interesting" functionality--e.g.,
you could build a simple read-only network file system client, or IP
forwarding/firewalling, or maybe build a distributed version of JOS
Implement a multi-processor version of JOS.
Run JOS on real hardware, and do a thorough evaluation of some
performance aspect. In particular, newer x86 chips have many features
designed to improve OS performance, but how effective are they? You
might also take advantage of some of the fancy performance monitoring
facilities built into modern CPUs.
Implement support for debugging (or maybe profiling) in JOS.
Design and implement a facility for downloading code into the kernel.
(Perhaps you could embed an existing interpreted language
implementation into the kernel.)
Implement and evaluate a facility for batching system calls in JOS, to
reduce the number of user-kernel crossings.
Implement the fastest IPC system you can for a modern CPU. Can you
"abuse" hyperthreading to make IPC go faster?
Implement support for superpages, to reduce the number of TLB faults
in applications that use more than 2MB of contiguous virtual memory.
paper for some ideas.)
Implement support for binary emulation of another operating system (or
a subset of another operating system), so that, for example, you can
run statically-linked Linux binaries on JOS (provided they don't use
esoteric system calls).