ECE 1746, Fall 2003, Project Suggestions

  1. Compare the performance and usability of event-based systems with thread-based systems.

    Recently there has been much work on providing efficient and scalable web service (SEDA, Capriccio, etc.). The argument seems to center around event-based programming vs. thread-based programming. In this project, students should implement a simple, static content, web-server using both methods and then compare the performance and ease of implementation of the two approaches. To simplify matters, assume that all web pages are cached in memory. Students should think carefully about their evaluation plan. For event-based programming, ask the instructor for an asynchronous I/O library.

  2. Implement a fault-tolerant large-scale distributed computation.

    Implement a large-scale distributed, perhaps scientific, algorithm of your choice. You can use an infrastructure such as QADPZ - Quite Advanced Distributed Parallel Zystem. Test the fault-tolerant behavior of your application, e.g., does the algorithm degrade gracefully if one node crashes. Modify your algorithm so that it is fault-tolerant in the face of node failure. One method of evaluation could be in terms of progress made by the application after node crashes, e.g., does the application make progress proportional to the number of surviving nodes in the system.

  3. Build a generic service that maintains consistent replicated data.

    You can assume any consistency model but for scalability reasons you may wish to choose eventual consistency where all the replicas of data eventually reach consistency but do allow intermediate, inconsistent accesses. You could use a DDS as described in the "Scalable, Distributed Data Structures for Internet Service Construction" paper in the reading list. Think about evaluation: does your system allow accesses as long as any replica is available? what is your replica selection mechanism? what about access latency and access performance?

  4. Build an application-specific replication service.

    This replication service should be tailored to an application's needs. For example, you could build a mailbox replication service such as Porcupine. Or you could implement a configuration file replication service for an application such as Mozilla. An important benefit of this service should be automatic reconciliation of divergent replicas. For example, the address book in mozilla of two inconsistent replicas might be the union of the two address books. For evaluation, you could should show how much automatic reconciliation is possible compared to a generic replication service.

  5. Implement a service analogous to the Internet Indirection Infrastructure.

    The Internet Indirection Infrastructure is a powerful mechanism for separating the sender from the receiver. This approach allows building mechanisms for mobility, multicasting and anycast. The question to explore in this project is how scalable is the infrastructure. For evaluation, build a dummy application to show scalability.

  6. Implement a fast file service using the Internet Indirection Infrastructure.

    This project will build an anycast service for the Internet Indirection Infrastructure. The anycast service is essentially a replica selection service. The idea is that the best replica, in terms of some performance metric such as bandwidth or latency, is returned to the user. The service can be deployed in the wide area or for server selection in a server cluster. For evaluation, show the performance gains due to your anycast service.

  7. Implement a simple, distributed file system.

    The file system should have the equivalent of the open, close, read and write calls. The file data should be cooperatively cached and kept in more than one node. Think about and implement your consistency policy for reads and writes. Discuss how keeping data in more than one node helps to provide fault tolerance. Your evaluation could be in terms of performance improvement due to caching as well as the improved fault tolerance due to multi-node caching.

  8. Implement a prefetching web proxy.

    Prototype a caching web proxy that attempts to predict future access behavior. Implement at least two caching algorithms in the proxy and evaluate these algorithms using web server logs or traces available on the Internet.

  9. Make a distributed shared memory (DSM) system.

    The idea is that processes running on different machines should be able to share an address space. Two existing DSM systems you can read about are Ivy and Treadmarks. You should have caching. Think about your consistency policy. For evaluation, you should have a program that can take good advantage of your DSM.

In all these projects, think about using an event-driven architecture for the servers that implement your service. The instructor will explain in class how servers can be designed using this architecture. Second, you will get extra points for your project if you evaluate your system in a wide-area testbed such as Netbed. Ask the instructor for more details about getting access to the infrastructure.