Final projects for CSG712 should have three components: (a) theory, (b) literature review, and (c) implementation and/or measurement. The relative balance between these aspects will vary depending on the topic. It should be at least 3500-4000 words, plus bibliography. (typical conference papers are about 900-1000 words per 2-column 10-point page including a modest number of figures or graphs)

Projects may be completed alone or in teams of two students; both students are expected to contribute in roughly equal amounts, as you'll almost certainly get the same grade. Reasonable standards of scholarship will apply - in particular, I expect your bibliography to reflect a reasonable amount of research. If anyone has questions about mechanical aspects of writing a paper - formatting, handling a bibliography, graphing data, incorporating graphs and figures - let me know and I can probably help you find a way to do it.

Proposed pedagogical projects:

• The homework 2 simulator - Wes has already claimed this one. The practical aspect would be to extend the simulator used in question 4 to make it more useful in teaching. The relevant literature to review and contrast to this work would be in the area of teaching operating systems. There wouldn't be any end-user experimentation, as that would be human-subject research and require IRB review.

Trace-driven simulation projects:

[The idea here is to generate a trace of real program operation (e.g. a list of memory address reads and writes), write a simulator which uses these traces, and run the simulator to measure or compare something. Note that in this context a "simulator" doesn't have to be very complicated - often a few perl scripts will do the job.]

• Page replacement algorithms - there are a large number of algorithms more modern than CLOCK, which dates to 1969 - CLOCK/Pro, 2Q, and CRAMM come to mind. Pick an algorithm, explain it (some, especially clock/pro, are very poorly described by the original authors), and do some simulations to compare it to LRU. (and maybe FIFO and OPT?)

• File system performance - there are a couple of existing disk performance simulators that you could use, and the idea here would be to implement a file system simulator which could transform a file access trace (e.g. gathered with ptrace) into a block access trace, and then determine the performance of that access trace on the actual disk. Then you could contrast either two file layout mechanisms (e.g. inode+indirect blocks vs. FAT) or a couple of caching/buffering strategies.
  

• Block storage performance - similar, but looking at e.g. RAID.

Other ideas:

• Benchmarking - if there's anything you're interested in from your research that you'd like to benchmark, it should be straightforward to turn it into a project.

• Virtualization

• Garbage collection

• Parallel file systems

For other ideas, you could look at the proceedings of the last few years of some of the major systems conferences and workshops:

  SOSP            http://portal.acm.org/toc.cfm?id=SERIES372
  ASPLOS        http://portal.acm.org/toc.cfm?id=SERIES311
    (and VEE:   http://portal.acm.org/toc.cfm?id=SERIES11259)
  SIGMETRICS  http://portal.acm.org/toc.cfm?id=SERIES328
  Eurosys       http://portal.acm.org/toc.cfm?id=SERIES11432
  SysML          (systems & machine learning)
  USENIX        http://www.usenix.org/events/byname/usenix.html
  HotOS          http://www.usenix.org/events/bytopic/hotos.html

  OSDI          http://portal.acm.org/toc.cfm?id=SERIES389
            http://www.usenix.org/events/bytopic/osdi.html

[Unresolved link removed.]