20.09.07
e-mail: rss39 _at_ eng.cam.ac.uk 


1. Qualitative/Quantitative Analysis of Page Replacement Algorithms:

Over the past decade a number of different page replacement algorithms
have been proposed (e.g. 2Q, ARC, MQ etc).  Although implemented in
simulation and niche products, there are no real implementations for
general purpose operating systems.

It would make an interesting project to implement a few of these
algorithms in a 2.6 Linux kernel and benchmark them on real-world
workloads.

Requirements: C, Linux/Kernel knowledge useful.


2. User-Level Communication over Ethernet:

A number of academic and commercial products (e.g. Myrianet, CLAN,
Infiniband) use a remote-virtual-memory transfer model.  In this
approach, a portion of the local process address space is mapped to
remote memory and any data operations transferred across the network
to the remote machine -- providing low-latency high bandwidth
communication.

The goal of this project is to create a remote-virtual-memory
architecture over ordinary 1G Ethernet.  There are interesting
questions to be answered both academically (what classes of
applications will benefit from this? what will the api look
like? what granularity of transfer? asynchronous or synchronous
transfers?) and technically (raw frames/tcp/udp? how do we do kernel
bypass?)

Requirements: C, Linux/Kernel knowledge useful.


3. Filesystem (via namespace) management:

In traditional architectures the block and buffer cache layers are
complete black-boxes to applications, and vice-versa.  A lot of effort
has been expended on learning what the application does through
observation and optimising for common cases.  

In this project the idea would be for applications to express
file use through a pseudo-namespace.  E.g. an application wishing to
do random, unbuffered I/O on a file would use the namespace
/nocache/random/file.txt to obtain a file descriptor while another
application wishing to do sequential buffered I/O would use
/cache/sequential/file.txt to obtain a descriptor.

Open questions are: 
(1) what would the namespace look like?
(2) How could applications express intent effectively and concisely?
(3) How could the kernel utilise this knowledge?
(4) Would this even be useful?

Requirements: C, Linux/Kernel (esp filesystem, block and device
layers) knowledge useful.