home search a-z help
University of Cambridge Computer Laboratory
Student Projects (2005)
Computer Laboratory > Research > Systems Research Group > NetOS > Student Projects (2005)


  • SCTP and BGP

    The Border Gateway Protocol, BGP, is the routing glue that holds the Internet together.

    It provides reachability information across all Internet Service providers, subject to complex policy constraints, so that end systems (host computers like the one you are reading this dcument on) can communicate each other. Packets flow using the Internet Datagram Protocol, which simply offers a best effort delivery from A to B. Routers between A and B look at the destination address in the header control information in datagrams (a.k.a. packets) to figure out where they go next, based on forwarding tables that they build, based on the information they learn from BGP.

    The Transmission Control Protocol, TCP is the end-to-end protocol that is used by pretty much all applications (e.g. web brosers talking to web servers, or skype users talking to each other) to provide reliability, flow control and congestion control, on top of the Internet Datagram Protocol.

    Only the end systems look at the TCP header control information. They use it to figure out what function a packet has (data, acknowledgement) and where it fits in a sequence of packets (or if it doesnt), and whether to speed up or slow down to allow the other end breathing space!

    Border routers use TCP to connect to each other, because the routing messages that they exchange with each other, to allow them to compute the reachability information, to allow them to build the forwarding tables, to allow them to forward the users' data packets (TCP/IP), to let everything work, have to be delivered in order, reliably, and with flow control.

    Recently, a new transport protocol, SCTP has been devised, which allows for a few new end-to-end functions to be offered as well as the ones TCP providers; these include: multi-homing; connection migration; multiplexing of data objects between different threads over a single transport session; and others.

    Recently, people have noticed that BGP is rather complex. Part of this compelxity is that (border) routers need to know whether their neighbours are working ok, and if not, take action. This may be implicit in the silence of a neighbour (shades of Assault on Precinct 13)

    Some people would like to re-engineer BGP to be more modular, so that there are way s to replace components of BGP cleanly - one thing to do would be for BGP neighbours to exchange messages using SCTP instead of TCP, as this might be more tractable.

    This project, should you choose to accept it Jim, is to
    i) analyse the BGP specifications and see how embroiled the use of TCP is in them. Extract the relevant pieces and see if the system can be respecified using SCTP instead.
    ii) Take a BGP public domain implementation and a public domain SCTP implementation, and design, build and test a system of BGP routers, under test load, to see if the system operates correctly. and of course, see how the performance changes (if at all).
    iii) report on all the above, to see if the design and implemention are any cleaner

    Contact: TImothy Griffin and

    Contact: Jon Crowcroft

  • GIST Overlay Networking Extension (GONE)

    Design: Using GIST on SCTP with HIP addresses, and k-ary neighbour we build an overlay architecture of SCTP use GIST and SCTP features to achieve
    i) multihoming
    ii) fault detection and recovery
    iii) HIP style addressing

    Evaluation should be of
    a) how well does SCTP/GIST work for this (e.g. compared to a pure TCP overlay or MIT's RON)?
    b) how well do the recovery schemes work
    c) maybe, how resilient is the architecture (given security designs in SCTP and GIST) to things like DDoS attacks...

    One question that is open, at least, is what is the expected workload/use to measure this under?

    Contact: Jon Crowcroft

  • A world of MIRRORS

    Mobile ad hoc networking have been an active research are for a decade, and the evaluations of many protocol proposals rely on simulations. These in turn depend on suitable models, especially of radio frequency propagation and mobility. Unfortunately, the simulation models to date are unsatisfactory, largely due to their lack of realism. This project aims to develop a tool to generate traces based on the modelling framework MIRRORS. The components and formulations of the models are sketched in the paper, so the project has more focus on implementation. Issues to consider include: i) How to implement the models in an extensible way? ii) How to manage the parameter values - passing them on the command line is not practical due to the number of parameters involved! iii) What to output?

    Depending on your interests, you could add various 'fun' parts, e.g., a visualiser showing the results, a GUI to allow the user to specify parameter values, or, more useful, trace generators to produce trace files compatible to commonly used simulators. You could identify many steps in this project, each of which can be seen as the completion mark, but producing a truely useful tool is non-trivial. If done right, it will certainly be a well-appreciated contribution to the research community.

    Contact: Wenjun Hu

  • Car alarm alternative

    There have been many recent initiatives involving networking with vehicles, either between vehicle or inside a vehicle. This project considers an alternative to car alarms. Observe that a car alarm often accidentally goes off, irritating the people around it rather than reminding the owner. The idea is to let an intelligent car text the owner's mobile (it should be a reasonable assumption that the owner will have one) under such a circumstance, and let the owner reset the 'alarm' remotely using the mobile. An actually system would probably involve some circuitry, but we can start with the software side.

    Contact: Wenjun Hu

  • Language Models, Scriptability & Abstractions for Network Traffic Processing

    Almost all applications that process network traffic, both on- and offline, overlap in large parts of functionality: state keeping, packet iteration, filtering, input abstraction, etc. The Netdude framework provides a pluggable architecture that allows authors to leverage efforts made by others to help build new processors with less time, more modularity, and (hopefully) better quality. One aspect the framework currently does not provide is scriptability -- writing C code is still required. This project will involve

    • investigating the applicability of the Usenix command line paradigm (piping & filtering output from one command into another, etc) to the problem -- the issue here is that some processing requires repeated scans of input (say, to strip incomplete TCP flows from a trace) and jumps in general
    • where necessary, a requirements analysis for features a purpose-specific scripting language (such as used in Bro or Click) should provide
    • extend the plugin architecture to purely scripted, single-file plugins (think Emacs or Gimp) that can be accessed from both C and the scripting level, and provide a scripting interface to libnetdude via SWIG.

    For more information, see Netdude and the corresponding paper.

    Contact: Christian Kreibich

  • Full-state VM Snapshots

    Our work on Xen currently has several components which support the snapshot of a running VM. This project would involve combining and synchronising the snapshot of a VM's memory, disks, and other relevant state. Ideally, a final demo would involve a tree-like graphical view of screen-shots of a VM through history, and allow old versions of the VM to be restarted (branching the tree) by clicking on them.

    Extra work on this project could involve exploring the more challenging issue of concurrently snapshotting a distributed system (i.e. many VMs) running on a set of hosts.

    Contact: andrew.warfield@cl.cam.ac.uk

  • The Flying Mouse

    This project explores a new interface for the PC build out of cheap, common components. Take a pen, attach some coloured LEDs to the end and wire them up to some buttons. Using a webcam, allow the pen to be used as a mouse, by waving it in the air in front of the screen. As LEDs are bright and different colours, image tracking should be relatively straight forward. The implementation should be completely integrated into an OS (preferably Linux or Windows), and so involves a decent range of fun hacking.

    Students making reasonable progress might consider (a) the addition of a second camera to implement a 3D interface, or (b) integration of some gesture recognition for common tasks.

    Contact: andrew.warfield@cl.cam.ac.uk

Sort of semi-locally suggested

Initial Point of Contact for these is: Jon Crowcroft

  • Project Title: TCP improvements for heterogeneous roaming
    Mobility impacts every layer of the OSI model. Many efforts have been made towards reducing handover latencies when roaming between two access points belonging to the same technology. Recent results show that it is possible to seamlessly roam between two IEEE 802.11b and keep handoff latencies below 100ms, enabling support for real-time applications on-the-move. However, when roaming is between different access technologies latency values increase considerable, depending on the link-layer characteristics of both radio access technologies. Experimental results, based on Mobile IP, show that vertical handover latency values can be expected to be close to 2.5 RTTs of the technology used for the registration process. To obtain these values we need to use the correct set of optimisations in the network layer.

    This value of 2.5 RTTs is close to the best that we can do at this layer, without affecting the network side and this is not enough to support real-time services.

    Additionally to this value, when the mobile devices deal with TCP connections (i.e. browsing and P2P traffic) there is a significant delay that needs to be considered: the adaptation time. We define adaptation time to be from the point at which the mobile node receives the first packet on the new interface, from the correspondent node, to the point where the new interface's throughput first reaches the value of the average throughput it achieves over the lifetime of the connection. Project: This project will measure, characterise the adaptation time, and propose and implement methods to reduce its impact on the transport layer. The aim is to reduce the overall latency. So far efforts in the IETF have been focused to solve network-layer mobility, but if we want to support seamless mobility we also need to tackle related issues in upper layers such as the transport layer. The main work will be done in traffic analysis and kernel modifications to the TCP/IP stack to implement the proposed methods to reduce the adaptation time.

    Related publication:

    David N. Cottingham, Pablo A. Vidales, Is Latency the Real Enemy in Next Generation Networks?. First International Workshop on Convergence of Heterogeneous Wireless Networks, July 2005

    Further info for this work and contact for

    Suggested by Dr. Pablo Vidales, now at DT Labs in Berlin.

  • MCP:- Multicast Copy Program

    It is often the case you want to copy the same file to multiple other machines. THere are a varieity of techniques. One is based on using IP multicast where available. To this end you also need a reliable multicast delivery layer - thats what MCP does.

    MCP uses TCP-XM, an extension of TCP to send data to multiple receivers either with multicast or with unicast if multicast is not availble to some of the receivers. The protocol is well specified and a user space implementation exists. This projecyt could do one of two things. First, a kernel version would be nice. Second, deploying it on the physics grid to real users would be interesting. Evaluation would be about performance (either speed, or number of receivers or both).

    There's quite a lot of implemenation to be done, and then quite a lot of experiments with a range of workloads and underlying network conditions.

    Contact: Jon Crowcroft


    This year, a net games company in Cambridge has suggested some projects.

    Initial Point of Contact for these is: Jon Crowcroft

    • Augmented-Reality on Symbian Camera Phones
      With increasing mobile phone processing power and camera capabilities fast becoming standard, the technology has now reached a level where augmented reality-based applications have become a real possibility. Gameware already possess the required 3D rendering and camera image acquisition technology that can be made available to the student for the project. Project: The project will investigate the technical constraints involved in implementing augmented-reality technology on today's high-end Symbian-based camera phones. This will involve porting aspects of the open source ARToolKit to Nokia Series 60 camera phones. Part of the project will also require the research and develop of efficient and robust image processing and pattern recognition algorithms suitable for the platform.
    • Evolving Hand-engineered 3D Virtual Creatures
      Background: Genetic representations for evolvable articulated virtual creatures are often at odds with the requirements of an underlying representation that supports arbitrary hand-designed virtual creatures. For example, evolvable 3D virtual creatures are often represented using recursive or generative genomes; hand-engineered creatures can be simply represented using genomes with a similar structure to the creature morphology. Project: This project will look into how these two requirements could be brought closer together, looking at a number of alternative approaches, such as developing a hybrid genetic representation, or designing a building process that enables relatively free-form building of articulated creatures based on a evolvable genetic representation, or designing suitable pattern- matching cross-over and mutation operations that can operate on a hand- built genomes.
    • Evaluation of AGEIA PhysX for the simulation of 3D Articulated Systems
      Background: Physics simulation provides the backbone for realistic virtual creature simulation and believable mixed-reality systems. the AGEIA physX engine (formally Novodex) is a cross-platform (PC, PS3 and Xbox 360) middleware physics simulation SDK that promises significant performance benefits over rival engines through the use of parallel- processing and hardware acceleration. Project: This project will examine the engine's performance and robustness under various conditions. In particular, the simulation of arbitrary-connected articulated powered systems, with the aim to understand the engine's suitability for simulating evolvable 3D virtual creatures. Development will be on a Windows PC.
    • Evolution and Islands
      Background: Large-scale virtual world simulations can be simulated over a network of distributed servers, each modelling a patch of terrain or a separate island. Servers (such as home PCs or mobile phones) have restricted resources and bandwidth and, in the case of mobile-based servers, the geographical proximity of servers to each other is always changing (a characteristic that could potentially be put to good use). These factors affect the way agents within the environment interact with each other. Project: This project will examine the issues involved in simulating distributed virtual world simulations, investigating the factors such as managing population sizes, suitable migration policies between servers, agent and server loses and latency, changing landscape topologies, etc.
    • Real-time TV Audience Interaction through Mobile Phones
      Background: Live interactive TV is becoming more commonplace through the use of mobile phones, which are ideally suited for spontaneous and instantaneous communication. For example, the use of SMS for voting or sending messages into live TV shows is becoming quite popular. 3G technologies offer benefits such as continuous interaction and individual feedback. Project: This project will research and develop a prototype to demonstrate the principles behind a system enabling mass audiences to interact live with a central server via their mobile phones (e.g. over GPRS). The work will look at the technical requirements of such a system and the constraints that will be imposed on it, such as latency, bandwidth requirements and client- side software requirements.